diff --git a/.gitmodules b/.gitmodules
index e69de29..fd49688 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "libs/tracy"]
+	path = libs/tracy
+	url = git@github.com:wolfpld/tracy.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 46d21b7..5c2f677 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,12 +3,19 @@ project(typescript)
 
 set(CMAKE_CXX_STANDARD 20)
 
-set(CMAKE_CXX_FLAGS "-Wall -Wextra -O2")
+# enable for profiling
+#add_definitions(-DTRACY_ENABLE)
+
+include_directories(libs/tracy/)
+
 list(APPEND CMAKE_MODULE_PATH libs/)
 
 #add_definitions(-DTRACY_ENABLE)
 #include_directories(libs/tracy/)
 
+add_subdirectory(libs/tracy)
+
+link_libraries(Tracy::TracyClient)
 add_subdirectory(src)
 
 include_directories(libs)
diff --git a/libs/tracy b/libs/tracy
new file mode 160000
index 0000000..a53c8be
--- /dev/null
+++ b/libs/tracy
@@ -0,0 +1 @@
+Subproject commit a53c8befdc914e58c0fbd1d159c11ff85d4f05df
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b50a1cc..a04ce9a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -5,6 +5,11 @@ add_definitions(-DTRACY_ENABLE)
 
 add_subdirectory(tests)
 
+set(CMAKE_CXX_FLAGS "-Wall -Wextra -O2")
+#set(CMAKE_CXX_FLAGS "-Wall -Wextra -O3 -ffast-math")
+
 add_library(typescript utf.h utf.cpp core.h core.cpp utilities.h utilities.cpp node_test.h node_test.cpp
         syntax_cursor.h syntax_cursor.cpp parser2.h parser2.cpp types.h types.cpp path.h path.cpp
-        factory.h factory.cpp parenthesizer.h parenthesizer.cpp scanner.h scanner.cpp)
+        factory.h factory.cpp parenthesizer.h parenthesizer.cpp scanner.h scanner.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/../libs/tracy/TracyClient.cpp
+        )
diff --git a/src/core.cpp b/src/core.cpp
index ca31af1..319a6a4 100644
--- a/src/core.cpp
+++ b/src/core.cpp
@@ -11,15 +11,30 @@ namespace ts::Debug {
 }
 
 namespace ts {
-    string substr(const string &str, int start, int length) {
+    string substr(const string &str, int start, optional<int> len) {
+        if (start <= 0 && len && len < 0) return "";
+        if (!len || *len < 0 || len > str.size()) *len = str.size();
         if (start < 0) start += str.length();
-        if (length < 0) length = str.length() + length - start;
-        if (length < 0) return "";
-        return str.substr(start, length);
+        return str.substr(start, *len);
     }
-    string substr(const string &str, int start) {
-        return substr(str, start, str.length());
+
+    //compatible with JavaScript's String.substring
+    string substring(const string &str, int start, optional<int> end) {
+        if (start < 0) start = 0;
+        int len = str.size();
+        if (end) {
+            if (*end < start) {
+                len = start - *end;
+                start = *end;
+            } else {
+                len = *end - start;
+            }
+        }
+        if (len < 0) len = 0;
+        if (start > str.size()) start = str.size();
+        return str.substr(start, len);
     }
+
     string replaceLeading(const string &text, const string &from, const string &to) {
         if (0 == text.find(from)) {
             string str = text;
diff --git a/src/core.h b/src/core.h
index 0a5fcd1..1480456 100644
--- a/src/core.h
+++ b/src/core.h
@@ -40,9 +40,11 @@ namespace ts {
         return const_hash(s);
     }
 
-    string substr(const string &str, int start, int length);
+    //compatible with JavaScript's String.substr
+    string substr(const string &str, int start, optional<int> len = {});
 
-    string substr(const string &str, int start);
+    //compatible with JavaScript's String.substring
+    string substring(const string &str, int start, optional<int> end = {});
 
     /**
      * shared_ptr has optional semantic already built-in, so we use it instead of std::optional<shared_ptr<>>,
@@ -157,6 +159,7 @@ namespace ts {
         }
         return false;
     }
+
     template<typename T>
     inline bool some(optional<vector<T>> array) {
         return array && !array->empty();
@@ -223,7 +226,10 @@ namespace ts {
 
     template<typename K, typename T>
     inline optional<T> set(unordered_map<K, T> &m, K key, T v) {
-        m[key] = v;
+//        m.insert_or_assign(key, v);
+        std::cout << "set map: " << key << ", " << v << "\n";
+//        m.insert({key, v});
+//        m[key] = v;
     }
 
     template<typename T, typename U>
diff --git a/src/factory.cpp b/src/factory.cpp
index b41be08..a207c12 100644
--- a/src/factory.cpp
+++ b/src/factory.cpp
@@ -18,45 +18,45 @@ namespace ts {
         return propagateChildFlags(std::move(node)) & ~(int) TransformFlags::ContainsPossibleTopLevelAwait;
     }
 
-    int Factory::propagateChildrenFlags(optional<NodeArray> children) {
+    int Factory::propagateChildrenFlags(sharedOpt<NodeArray> children) {
         return children ? children->transformFlags : (int) TransformFlags::None;
     }
 
-    void Factory::aggregateChildrenFlags(NodeArray &children) {
+    void Factory::aggregateChildrenFlags(shared<NodeArray> &children) {
         int subtreeFlags = (int) TransformFlags::None;
-        for (auto &child: children.list) {
+        for (auto &child: children->list) {
             subtreeFlags |= propagateChildFlags(child);
         }
-        children.transformFlags = subtreeFlags;
+        children->transformFlags = subtreeFlags;
     }
 
-    NodeArray Factory::createNodeArray(optional<NodeArray> elements, optional<bool> hasTrailingComma) {
+    shared<NodeArray> Factory::createNodeArray(sharedOpt<NodeArray> elements, optional<bool> hasTrailingComma) {
         if (elements) {
             if (!hasTrailingComma || elements->hasTrailingComma == hasTrailingComma) {
                 // Ensure the transform flags have been aggregated for this NodeArray
                 if (elements->transformFlags == (int) types::TransformFlags::None) {
-                    aggregateChildrenFlags(*elements);
+                    aggregateChildrenFlags(elements);
                 }
 //                Debug.attachNodeArrayDebugInfo(elements);
-                return *elements;
+                return elements;
             }
         }
 
         // This *was* a `NodeArray`, but the `hasTrailingComma` option differs. Recreate the
         // array with the same elements, text range, and transform flags but with the updated
         // value for `hasTrailingComma`
-        NodeArray array;
-        if (elements) array = *elements;
-        array.pos = elements->pos;
-        array.end = elements->end;
-        array.hasTrailingComma = *hasTrailingComma;
-        array.transformFlags = elements->transformFlags;
+        auto array = make_shared<NodeArray>();
+        if (elements) array = elements;
+        array->pos = elements->pos;
+        array->end = elements->end;
+        array->hasTrailingComma = *hasTrailingComma;
+        array->transformFlags = elements->transformFlags;
 //            Debug.attachNodeArrayDebugInfo(array);
         return array;
     }
 
-    optional<NodeArray> Factory::asNodeArray(optional<NodeArray> array) {
-        return array;
+    sharedOpt<NodeArray> Factory::asNodeArray(sharedOpt<NodeArray> elements) {
+        return elements;
     }
 
     // @api
@@ -154,11 +154,11 @@ namespace ts {
 //        }
 
     void Factory::setName(shared<Identifier> &lName, shared<Node> rName) {
-        lName = dynamic_pointer_cast<Identifier>(rName);
+        lName = reinterpret_pointer_cast<Identifier>(rName);
     }
 
     void Factory::setName(shared<PrivateIdentifier> &lName, shared<Node> rName) {
-        lName = dynamic_pointer_cast<PrivateIdentifier>(rName);
+        lName = reinterpret_pointer_cast<PrivateIdentifier>(rName);
     }
 
     void Factory::setName(shared<Node> &lName, shared<Node> rName) {
@@ -246,11 +246,11 @@ namespace ts {
     }
 
     // @api
-    shared<Identifier> Factory::createIdentifier(string text, optional<NodeArray> typeArguments, optional<SyntaxKind> originalKeywordKind) {
+    shared<Identifier> Factory::createIdentifier(string text, sharedOpt<NodeArray> typeArguments, optional<SyntaxKind> originalKeywordKind) {
         auto node = createBaseIdentifier(std::move(text), originalKeywordKind);
         if (typeArguments) {
             // NOTE: we do not use `setChildren` here because typeArguments in an identifier do not contribute to transformations
-            node->typeArguments = createNodeArray(*typeArguments);
+            node->typeArguments = createNodeArray(typeArguments);
         }
         if (node->originalKeywordKind == SyntaxKind::AwaitKeyword) {
             node->transformFlags |= (int) TransformFlags::ContainsPossibleTopLevelAwait;
@@ -352,7 +352,7 @@ namespace ts {
     shared<QualifiedName> Factory::createQualifiedName(shared<Node> left, NameType right) {
         auto node = createBaseNode<QualifiedName>(SyntaxKind::QualifiedName);
         node->left = left;
-        node->right = dynamic_pointer_cast<Identifier>(asName(right));
+        node->right = reinterpret_pointer_cast<Identifier>(asName(right));
         node->transformFlags |=
                 propagateChildFlags(node->left) |
                 propagateIdentifierNameFlags(node->right);
@@ -390,22 +390,22 @@ namespace ts {
 //        //
 //
 //        // @api
-//        function createTypeParameterDeclaration(optional<NodeArray> modifiers, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
+//        function createTypeParameterDeclaration(sharedOpt<NodeArray> modifiers, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
 //        /** @deprecated */
 //        function createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
    shared<TypeParameterDeclaration> Factory::createTypeParameterDeclaration(
-            optional<variant<NodeArray, shared<Node>, string>> modifiersOrName,
+            optional<variant<shared<NodeArray>, shared<Node>, string>> modifiersOrName,
             optional<variant<shared<TypeNode>, shared<Identifier>, string>> nameOrConstraint,
             sharedOpt<TypeNode> constraintOrDefault,
             sharedOpt<TypeNode> defaultType
     ) {
         NameType name = "";
-        optional<NodeArray> modifiers;
+        sharedOpt<NodeArray> modifiers;
         sharedOpt<TypeNode> constraint = constraintOrDefault;
 
         if (modifiersOrName) {
-            if (holds_alternative<NodeArray>(*modifiersOrName)) {
-                modifiers = get<NodeArray>(*modifiersOrName);
+            if (holds_alternative<shared<NodeArray>>(*modifiersOrName)) {
+                modifiers = get<shared<NodeArray>>(*modifiersOrName);
             } else if (holds_alternative<string>(*modifiersOrName)) {
                 name = get<string>(*modifiersOrName);
             } else if (holds_alternative<shared<Node>>(*modifiersOrName)) {
@@ -435,7 +435,7 @@ namespace ts {
 //            }
         auto node = createBaseNamedDeclaration<TypeParameterDeclaration>(
                 SyntaxKind::TypeParameter,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 modifiers,
                 name
         );
@@ -446,7 +446,7 @@ namespace ts {
     }
 
 //        // @api
-//        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, optional<NodeArray> modifiers, name: Identifier, constraint: TypeNode | undefined, defaultsharedOpt<TypeNode> type): TypeParameterDeclaration;
+//        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, sharedOpt<NodeArray> modifiers, name: Identifier, constraint: TypeNode | undefined, defaultsharedOpt<TypeNode> type): TypeParameterDeclaration;
 //        /** @deprecated */
 //        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultsharedOpt<TypeNode> type): TypeParameterDeclaration;
 //        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiersOrName: readonly Modifier[] | Identifier | undefined, nameOrConstraint: Identifier | TypeNode | undefined, constraintOrDefault: TypeNode | undefined, defaultType?: TypeNode | undefined) {
@@ -473,8 +473,8 @@ namespace ts {
 
     // @api
     shared<ParameterDeclaration> Factory::createParameterDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             sharedOpt<DotDotDotToken> dotDotDotToken,
             NameType name,
             sharedOpt<QuestionToken> questionToken,
@@ -507,8 +507,8 @@ namespace ts {
 //        // @api
 //        function updateParameterDeclaration(
 //            node: ParameterDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            dotDotDotToken: DotDotDotToken | undefined,
 //            name: string | BindingName,
 //            sharedOpt<QuestionToken> questionToken,
@@ -550,14 +550,14 @@ namespace ts {
 
     // @api
     shared<PropertySignature> Factory::createPropertySignature(
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
             sharedOpt<QuestionToken> questionToken,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseNamedDeclaration<PropertySignature>(
                 SyntaxKind::PropertySignature,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 modifiers,
                 name
         );
@@ -570,7 +570,7 @@ namespace ts {
 //        // @api
 //        function updatePropertySignature(
 //            node: PropertySignature,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
 //            sharedOpt<QuestionToken> questionToken,
 //            sharedOpt<TypeNode> type
@@ -585,8 +585,8 @@ namespace ts {
 
     // @api
     shared<PropertyDeclaration> Factory::createPropertyDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
             sharedOpt<Node> questionOrExclamationToken,
             sharedOpt<TypeNode> type,
@@ -600,8 +600,8 @@ namespace ts {
                 type,
                 initializer
         );
-        node->questionToken = questionOrExclamationToken && isQuestionToken(questionOrExclamationToken) ? dynamic_pointer_cast<QuestionToken>(questionOrExclamationToken) : nullptr;
-        node->exclamationToken = questionOrExclamationToken && isExclamationToken(questionOrExclamationToken) ? dynamic_pointer_cast<ExclamationToken>(questionOrExclamationToken) : nullptr;
+        node->questionToken = questionOrExclamationToken && isQuestionToken(questionOrExclamationToken) ? reinterpret_pointer_cast<QuestionToken>(questionOrExclamationToken) : nullptr;
+        node->exclamationToken = questionOrExclamationToken && isExclamationToken(questionOrExclamationToken) ? reinterpret_pointer_cast<ExclamationToken>(questionOrExclamationToken) : nullptr;
         node->transformFlags |=
                 propagateChildFlags(node->questionToken) |
                 propagateChildFlags(node->exclamationToken) |
@@ -618,8 +618,8 @@ namespace ts {
 //        // @api
 //        function updatePropertyDeclaration(
 //            node: PropertyDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            NameType name,
 //            questionOrExclamationToken: QuestionToken | ExclamationToken | undefined,
 //            sharedOpt<TypeNode> type,
@@ -638,16 +638,16 @@ namespace ts {
 //
     // @api
     shared<MethodSignature> Factory::createMethodSignature(
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
             sharedOpt<QuestionToken> questionToken,
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseSignatureDeclaration<MethodSignature>(
                 SyntaxKind::MethodSignature,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 modifiers,
                 name,
                 typeParameters,
@@ -662,7 +662,7 @@ namespace ts {
 //        // @api
 //        function updateMethodSignature(
 //            node: MethodSignature,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
 //            sharedOpt<QuestionToken> questionToken,
 //            typeParameters: NodeArray<TypeParameterDeclaration> | undefined,
@@ -681,13 +681,13 @@ namespace ts {
 //
     // @api
     shared<MethodDeclaration> Factory::createMethodDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             sharedOpt<AsteriskToken> asteriskToken,
             NameType name,
             sharedOpt<QuestionToken> questionToken,
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type,
             sharedOpt<Block> body
     ) {
@@ -725,13 +725,13 @@ namespace ts {
 //        // @api
 //        function updateMethodDeclaration(
 //            node: MethodDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            sharedOpt<AsteriskToken> asteriskToken,
 //            name: PropertyName,
 //            sharedOpt<QuestionToken> questionToken,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //           sharedOpt<Block> body
 //        ) {
@@ -750,8 +750,8 @@ namespace ts {
 //
     // @api
     shared<ClassStaticBlockDeclaration> Factory::createClassStaticBlockDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             shared<Block> body
     ) {
         auto node = createBaseNamedDeclaration<ClassStaticBlockDeclaration>(
@@ -768,8 +768,8 @@ namespace ts {
 //        // @api
 //        function updateClassStaticBlockDeclaration(
 //            node: ClassStaticBlockDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            shared<Block> block
 //        ): ClassStaticBlockDeclaration {
 //            return node->decorators != decorators
@@ -781,9 +781,9 @@ namespace ts {
 
     // @api
     shared<ConstructorDeclaration> Factory::createConstructorDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
-            NodeArray parameters,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
+            shared<NodeArray> parameters,
             sharedOpt<Block> body
     ) {
         auto node = createBaseFunctionLikeDeclaration<ConstructorDeclaration>(
@@ -803,9 +803,9 @@ namespace ts {
 //        // @api
 //        function updateConstructorDeclaration(
 //            node: ConstructorDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
+//            shared<NodeArray> parameters,
 //           sharedOpt<Block> body
 //        ) {
 //            return node->decorators != decorators
@@ -818,10 +818,10 @@ namespace ts {
 //
     // @api
     shared<GetAccessorDeclaration> Factory::createGetAccessorDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
-            NodeArray parameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type,
             sharedOpt<Block> body
     ) {
@@ -840,10 +840,10 @@ namespace ts {
 //        // @api
 //        function updateGetAccessorDeclaration(
 //            node: GetAccessorDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
-//            NodeArray parameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //           sharedOpt<Block> body
 //        ) {
@@ -859,10 +859,10 @@ namespace ts {
 
     // @api
     shared<SetAccessorDeclaration> Factory::createSetAccessorDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
-            NodeArray parameters,
+            shared<NodeArray> parameters,
             sharedOpt<Block> body
     ) {
         return createBaseFunctionLikeDeclaration<SetAccessorDeclaration>(
@@ -880,10 +880,10 @@ namespace ts {
 //        // @api
 //        function updateSetAccessorDeclaration(
 //            node: SetAccessorDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
-//            NodeArray parameters,
+//            shared<NodeArray> parameters,
 //           sharedOpt<Block> body
 //        ) {
 //            return node->decorators != decorators
@@ -897,14 +897,14 @@ namespace ts {
 //
     // @api
     shared<CallSignatureDeclaration> Factory::createCallSignature(
-            optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters,
-            NodeTypeArray(ParameterDeclaration) parameters,
+            sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters,
+            shared<NodeTypeArray(ParameterDeclaration)> parameters,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseSignatureDeclaration<CallSignatureDeclaration>(
                 SyntaxKind::CallSignature,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 /*name*/ {},
                 typeParameters,
                 parameters,
@@ -930,14 +930,14 @@ namespace ts {
 //
     // @api
     shared<ConstructSignatureDeclaration> Factory::createConstructSignature(
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseSignatureDeclaration<ConstructSignatureDeclaration>(
                 SyntaxKind::ConstructSignature,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 /*name*/ {},
                 typeParameters,
                 parameters,
@@ -963,9 +963,9 @@ namespace ts {
 //
     // @api
     shared<IndexSignatureDeclaration> Factory::createIndexSignature(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
-            NodeArray parameters,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseSignatureDeclaration<IndexSignatureDeclaration>(
@@ -984,9 +984,9 @@ namespace ts {
 //        // @api
 //        function updateIndexSignature(
 //            node: IndexSignatureDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
+//            shared<NodeArray> parameters,
 //            shared<TypeNode> type
 //        ) {
 //            return node->parameters != parameters
@@ -1043,7 +1043,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<TypeReferenceNode> Factory::createTypeReferenceNode(NameType typeName, optional<NodeArray> typeArguments) {
+    shared<TypeReferenceNode> Factory::createTypeReferenceNode(NameType typeName, sharedOpt<NodeArray> typeArguments) {
         auto node = createBaseNode<TypeReferenceNode>(SyntaxKind::TypeReference);
         node->typeName = asName(typeName);
         if (typeArguments) node->typeArguments = parenthesizer.parenthesizeTypeArguments(createNodeArray(typeArguments));
@@ -1061,14 +1061,14 @@ namespace ts {
 
     // @api
     shared<FunctionTypeNode> Factory::createFunctionTypeNode(
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseSignatureDeclaration<FunctionTypeNode>(
                 SyntaxKind::FunctionType,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 /*name*/ {},
                 typeParameters,
                 parameters,
@@ -1100,14 +1100,14 @@ namespace ts {
 //        }
 
     shared<ConstructorTypeNode> Factory::createConstructorTypeNode1(
-            optional<NodeArray> modifiers,
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> modifiers,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type
     ) {
         auto node = createBaseSignatureDeclaration<ConstructorTypeNode>(
                 SyntaxKind::ConstructorType,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 modifiers,
                 /*name*/ {},
                 typeParameters,
@@ -1120,11 +1120,11 @@ namespace ts {
 
 //        /** @deprecated */
 //        function createConstructorTypeNode2(
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type
 //        ): ConstructorTypeNode {
-//            return createConstructorTypeNode1(/*modifiers*/ {}, typeParameters, parameters, type);
+//            return createConstructorTypeNode1(/*modifiers*/ nullptr, typeParameters, parameters, type);
 //        }
 //
 //        // @api
@@ -1136,7 +1136,7 @@ namespace ts {
 //
 //        function updateConstructorTypeNode1(
 //            node: ConstructorTypeNode,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            typeParameters: NodeArray<TypeParameterDeclaration> | undefined,
 //            parameters: NodeArray<ParameterDeclaration>,
 //            sharedOpt<TypeNode> type
@@ -1160,7 +1160,7 @@ namespace ts {
 //        }
 //
     // @api
-    shared<TypeQueryNode> Factory::createTypeQueryNode(shared<NodeUnion(EntityName)> exprName, optional<NodeArray> typeArguments) {
+    shared<TypeQueryNode> Factory::createTypeQueryNode(shared<NodeUnion(EntityName)> exprName, sharedOpt<NodeArray> typeArguments) {
         auto node = createBaseNode<TypeQueryNode>(SyntaxKind::TypeQuery);
         node->exprName = exprName;
         if (typeArguments) node->typeArguments = parenthesizer.parenthesizeTypeArguments(typeArguments);
@@ -1177,7 +1177,7 @@ namespace ts {
 //        }
 //
     // @api
-    shared<TypeLiteralNode> Factory::createTypeLiteralNode(optional<NodeArray> members) {
+    shared<TypeLiteralNode> Factory::createTypeLiteralNode(sharedOpt<NodeArray> members) {
         auto node = createBaseNode<TypeLiteralNode>(SyntaxKind::TypeLiteral);
         node->members = createNodeArray(members);
         node->transformFlags = (int) TransformFlags::ContainsTypeScript;
@@ -1207,7 +1207,7 @@ namespace ts {
 //        }
 //
     // @api
-    shared<TupleTypeNode> Factory::createTupleTypeNode(NodeArray elements) {
+    shared<TupleTypeNode> Factory::createTupleTypeNode(shared<NodeArray> elements) {
         auto node = createBaseNode<TupleTypeNode>(SyntaxKind::TupleType);
         node->elements = createNodeArray(parenthesizer.parenthesizeElementTypesOfTupleType(elements));
         node->transformFlags = (int) TransformFlags::ContainsTypeScript;
@@ -1279,7 +1279,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<UnionTypeNode> Factory::createUnionTypeNode(NodeArray types) {
+    shared<UnionTypeNode> Factory::createUnionTypeNode(shared<NodeArray> types) {
         return createUnionOrIntersectionTypeNode<UnionTypeNode>(SyntaxKind::UnionType, types, CALLBACK(parenthesizer.parenthesizeConstituentTypesOfUnionType));
     }
 
@@ -1289,7 +1289,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<IntersectionTypeNode> Factory::createIntersectionTypeNode(NodeArray types) {
+    shared<IntersectionTypeNode> Factory::createIntersectionTypeNode(shared<NodeArray> types) {
         return createUnionOrIntersectionTypeNode<IntersectionTypeNode>(SyntaxKind::IntersectionType, types, CALLBACK(parenthesizer.parenthesizeConstituentTypesOfIntersectionType));
     }
 
@@ -1335,7 +1335,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<TemplateLiteralTypeNode> Factory::createTemplateLiteralType(shared<TemplateHead> head, NodeArray templateSpans) {
+    shared<TemplateLiteralTypeNode> Factory::createTemplateLiteralType(shared<TemplateHead> head, shared<NodeArray> templateSpans) {
         auto node = createBaseNode<TemplateLiteralTypeNode>(SyntaxKind::TemplateLiteralType);
         node->head = head;
         node->templateSpans = createNodeArray(templateSpans);
@@ -1357,13 +1357,13 @@ namespace ts {
     shared<ImportTypeNode> Factory::createImportTypeNode(
             shared<TypeNode> argument,
             optional<variant<shared<NodeUnion(EntityName)>, shared<ImportTypeAssertionContainer>>> qualifierOrAssertions,
-            optional<variant<shared<NodeUnion(EntityName)>, NodeArray>> typeArgumentsOrQualifier,
-            optional<variant<bool, NodeArray>> isTypeOfOrTypeArguments,
+            optional<variant<shared<NodeUnion(EntityName)>, shared<NodeArray>>> typeArgumentsOrQualifier,
+            optional<variant<bool, shared<NodeArray>>> isTypeOfOrTypeArguments,
             optional<bool> isTypeOf
     ) {
         sharedOpt<ImportTypeAssertionContainer> assertion;
         sharedOpt<NodeUnion(EntityName)> qualifier;
-        optional<NodeArray> typeArguments;
+        sharedOpt<NodeArray> typeArguments;
         if (qualifierOrAssertions) {
             if (holds_alternative<shared<ImportTypeAssertionContainer>>(*qualifierOrAssertions)) {
                 assertion = get<shared<ImportTypeAssertionContainer>>(*qualifierOrAssertions);
@@ -1373,16 +1373,16 @@ namespace ts {
         }
 
         if (typeArgumentsOrQualifier) {
-            if (holds_alternative<NodeArray>(*typeArgumentsOrQualifier)) {
-                typeArguments = get<NodeArray>(*typeArgumentsOrQualifier);
+            if (holds_alternative<shared<NodeArray>>(*typeArgumentsOrQualifier)) {
+                typeArguments = get<shared<NodeArray>>(*typeArgumentsOrQualifier);
             } else if (holds_alternative<shared<NodeUnion(EntityName)>>(*typeArgumentsOrQualifier)) {
                 qualifier = get<shared<NodeUnion(EntityName)>>(*typeArgumentsOrQualifier);
             }
         }
 
         if (isTypeOfOrTypeArguments) {
-            if (holds_alternative<NodeArray>(*isTypeOfOrTypeArguments)) {
-                typeArguments = get<NodeArray>(*isTypeOfOrTypeArguments);
+            if (holds_alternative<shared<NodeArray>>(*isTypeOfOrTypeArguments)) {
+                typeArguments = get<shared<NodeArray>>(*isTypeOfOrTypeArguments);
             } else if (holds_alternative<bool>(*isTypeOfOrTypeArguments)) {
                 isTypeOf = get<bool>(*isTypeOfOrTypeArguments);
             }
@@ -1398,15 +1398,15 @@ namespace ts {
         node->argument = argument;
         node->assertions = assertion;
         node->qualifier = qualifier;
-        if (typeArguments) node->typeArguments = parenthesizer.parenthesizeTypeArguments(*typeArguments);
+        if (typeArguments) node->typeArguments = parenthesizer.parenthesizeTypeArguments(typeArguments);
         node->isTypeOf = isTrue(isTypeOf);
         node->transformFlags = (int) TransformFlags::ContainsTypeScript;
         return node;
     }
 
 //        // @api
-//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, optional<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
-//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, optional<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
+//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, sharedOpt<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
+//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, sharedOpt<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
 //        function updateImportTypeNode(
 //            node: ImportTypeNode,
 //            argument: TypeNode,
@@ -1494,7 +1494,7 @@ namespace ts {
             sharedOpt<TypeNode> nameType,
             sharedOpt<Node> questionToken, //: QuestionToken | PlusToken | MinusToken | undefined,
             sharedOpt<TypeNode> type,
-            optional<NodeArray> members
+            sharedOpt<NodeArray> members
     ) {
         auto node = createBaseNode<MappedTypeNode>(SyntaxKind::MappedType);
         node->readonlyToken = readonlyToken;
@@ -1508,7 +1508,7 @@ namespace ts {
     }
 
 //        // @api
-//        function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, namesharedOpt<TypeNode> type, questionToken: QuestionToken | PlusToken | MinusToken | undefined, sharedOpt<TypeNode> type, optional<NodeArray> members): MappedTypeNode {
+//        function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, namesharedOpt<TypeNode> type, questionToken: QuestionToken | PlusToken | MinusToken | undefined, sharedOpt<TypeNode> type, sharedOpt<NodeArray> members): MappedTypeNode {
 //            return node->readonlyToken != readonlyToken
 //                || node->typeParameter != typeParameter
 //                || node->nameType != nameType
@@ -1539,7 +1539,7 @@ namespace ts {
 //        //
 //
     // @api
-    shared<ObjectBindingPattern> Factory::createObjectBindingPattern(NodeArray elements) {
+    shared<ObjectBindingPattern> Factory::createObjectBindingPattern(shared<NodeArray> elements) {
         auto node = createBaseNode<ObjectBindingPattern>(SyntaxKind::ObjectBindingPattern);
         node->elements = createNodeArray(elements);
         node->transformFlags |=
@@ -1562,7 +1562,7 @@ namespace ts {
 //        }
 //
     // @api
-    shared<ArrayBindingPattern> Factory::createArrayBindingPattern(NodeArray elements) {
+    shared<ArrayBindingPattern> Factory::createArrayBindingPattern(shared<NodeArray> elements) {
         auto node = createBaseNode<ArrayBindingPattern>(SyntaxKind::ArrayBindingPattern);
         node->elements = createNodeArray(elements);
         node->transformFlags |=
@@ -1588,8 +1588,8 @@ namespace ts {
     ) {
         auto node = createBaseBindingLikeDeclaration<BindingElement>(
                 SyntaxKind::BindingElement,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 name,
                 initializer ? parenthesizer.parenthesizeExpressionForDisallowedComma(initializer) : nullptr
         );
@@ -1620,7 +1620,7 @@ namespace ts {
 //        //
 
     // @api
-    shared<ArrayLiteralExpression> Factory::createArrayLiteralExpression(optional<NodeArray> elements, bool multiLine) {
+    shared<ArrayLiteralExpression> Factory::createArrayLiteralExpression(sharedOpt<NodeArray> elements, bool multiLine) {
         auto node = createBaseExpression<ArrayLiteralExpression>(SyntaxKind::ArrayLiteralExpression);
         // Ensure we add a trailing comma for something like `[NumericLiteral(1), NumericLiteral(2), OmittedExpresion]` so that
         // we end up with `[1, 2, ,]` instead of `[1, 2, ]` otherwise the `OmittedExpression` will just end up being treated like
@@ -1641,7 +1641,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<ObjectLiteralExpression> Factory::createObjectLiteralExpression(optional<NodeArray> properties, bool multiLine) {
+    shared<ObjectLiteralExpression> Factory::createObjectLiteralExpression(sharedOpt<NodeArray> properties, bool multiLine) {
         auto node = createBaseExpression<ObjectLiteralExpression>(SyntaxKind::ObjectLiteralExpression);
         node->properties = createNodeArray(properties);
         node->multiLine = multiLine;
@@ -1774,7 +1774,7 @@ namespace ts {
 //        }
 //
     // @api
-    shared<CallExpression> Factory::createCallExpression(shared<Expression> expression, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray) {
+    shared<CallExpression> Factory::createCallExpression(shared<Expression> expression, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray) {
         auto node = createBaseExpression<CallExpression>(SyntaxKind::CallExpression);
         node->expression = parenthesizer.parenthesizeLeftSideOfAccess(expression);
         node->typeArguments = asNodeArray(typeArguments);
@@ -1795,7 +1795,7 @@ namespace ts {
     }
 
     // @api
-    shared<CallChain> Factory::createCallChain(shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray) {
+    shared<CallChain> Factory::createCallChain(shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray) {
         auto node = createBaseExpression<CallChain>(SyntaxKind::CallExpression);
         node->flags |= (int) NodeFlags::OptionalChain;
         node->expression = parenthesizer.parenthesizeLeftSideOfAccess(expression);
@@ -1818,7 +1818,7 @@ namespace ts {
     }
 
     // @api
-    shared<CallChain> Factory::updateCallChain(shared<CallChain> node, shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, optional<NodeArray> typeArguments, NodeArray argumentsArray) {
+    shared<CallChain> Factory::updateCallChain(shared<CallChain> node, shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, sharedOpt<NodeArray> typeArguments, shared<NodeArray> argumentsArray) {
         Debug::asserts(!!(node->flags & (int) NodeFlags::OptionalChain), "Cannot update a CallExpression using updateCallChain. Use updateCall instead.");
         return node->expression != expression
                || node->questionDotToken != questionDotToken
@@ -1829,7 +1829,7 @@ namespace ts {
     }
 
     // @api
-    shared<CallExpression> Factory::updateCallExpression(shared<CallExpression> node, shared<Expression> expression, optional<NodeArray> typeArguments, NodeArray argumentsArray) {
+    shared<CallExpression> Factory::updateCallExpression(shared<CallExpression> node, shared<Expression> expression, sharedOpt<NodeArray> typeArguments, shared<NodeArray> argumentsArray) {
         if (isCallChain(node)) {
             return updateCallChain(node, expression, node->questionDotToken, typeArguments, argumentsArray);
         }
@@ -1841,11 +1841,11 @@ namespace ts {
     }
 
     // @api
-    shared<NewExpression> Factory::createNewExpression(shared<Expression> expression, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray) {
+    shared<NewExpression> Factory::createNewExpression(shared<Expression> expression, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray) {
         auto node = createBaseExpression<NewExpression>(SyntaxKind::NewExpression);
         node->expression = parenthesizer.parenthesizeExpressionOfNew(expression);
         node->typeArguments = asNodeArray(typeArguments);
-        if (argumentsArray) node->arguments = parenthesizer.parenthesizeExpressionsOfCommaDelimitedList(*argumentsArray);
+        if (argumentsArray) node->arguments = parenthesizer.parenthesizeExpressionsOfCommaDelimitedList(argumentsArray);
         node->transformFlags |=
                 propagateChildFlags(node->expression) |
                 propagateChildrenFlags(node->typeArguments) |
@@ -1858,7 +1858,7 @@ namespace ts {
     }
 
 //        // @api
-//        function updateNewExpression(node: NewExpression, shared<Expression> expression, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray) {
+//        function updateNewExpression(node: NewExpression, shared<Expression> expression, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray) {
 //            return node->expression != expression
 //                || node->typeArguments != typeArguments
 //                || node->arguments != argumentsArray
@@ -1867,7 +1867,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<TaggedTemplateExpression> Factory::createTaggedTemplateExpression(shared<Expression> tag, optional<NodeArray> typeArguments, shared<NodeUnion(TemplateLiteral)> templateLiteral) {
+    shared<TaggedTemplateExpression> Factory::createTaggedTemplateExpression(shared<Expression> tag, sharedOpt<NodeArray> typeArguments, shared<NodeUnion(TemplateLiteral)> templateLiteral) {
         auto node = createBaseExpression<TaggedTemplateExpression>(SyntaxKind::TaggedTemplateExpression);
         node->tag = parenthesizer.parenthesizeLeftSideOfAccess(tag);
         node->typeArguments = asNodeArray(typeArguments);
@@ -1887,7 +1887,7 @@ namespace ts {
     }
 //
 //        // @api
-//        function updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, optional<NodeArray> typeArguments, template: TemplateLiteral) {
+//        function updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, sharedOpt<NodeArray> typeArguments, template: TemplateLiteral) {
 //            return node->tag != tag
 //                || node->typeArguments != typeArguments
 //                || node->template != template
@@ -1932,17 +1932,17 @@ namespace ts {
 
     // @api
     shared<FunctionExpression> Factory::createFunctionExpression(
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> modifiers,
             sharedOpt<AsteriskToken> asteriskToken,
             NameType name,
-            optional<NodeArray> typeParameters,
-            optional<NodeArray> parameters,
+            sharedOpt<NodeArray> typeParameters,
+            sharedOpt<NodeArray> parameters,
             sharedOpt<TypeNode> type,
             shared<Block> body
     ) {
         auto node = createBaseFunctionLikeDeclaration<FunctionExpression>(
                 SyntaxKind::FunctionExpression,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 modifiers,
                 name,
                 typeParameters,
@@ -1970,11 +1970,11 @@ namespace ts {
 //        // @api
 //        function updateFunctionExpression(
 //            node: FunctionExpression,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            sharedOpt<AsteriskToken> asteriskToken,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //            shared<Block> block
 //        ) {
@@ -1990,16 +1990,16 @@ namespace ts {
 //        }
     // @api
     shared<ArrowFunction> Factory::createArrowFunction(
-            optional<NodeArray> modifiers,
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> modifiers,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type,
             sharedOpt<EqualsGreaterThanToken> equalsGreaterThanToken,
             shared<NodeUnion(ConciseBody)> body
     ) {
         auto node = createBaseFunctionLikeDeclaration<ArrowFunction>(
                 SyntaxKind::ArrowFunction,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 modifiers,
                 /*name*/ {},
                 typeParameters,
@@ -2020,9 +2020,9 @@ namespace ts {
 //        // @api
 //        function updateArrowFunction(
 //            node: ArrowFunction,
-//            optional<NodeArray> modifiers,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> modifiers,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //            equalsGreaterThanToken: EqualsGreaterThanToken,
 //            body: ConciseBody
@@ -2253,7 +2253,7 @@ namespace ts {
 //        }
 
     // @api
-    shared<TemplateExpression> Factory::createTemplateExpression(shared<TemplateHead> head, NodeArray templateSpans) {
+    shared<TemplateExpression> Factory::createTemplateExpression(shared<TemplateHead> head, shared<NodeArray> templateSpans) {
         auto node = createBaseExpression<TemplateExpression>(SyntaxKind::TemplateExpression);
         node->head = head;
         node->templateSpans = createNodeArray(templateSpans);
@@ -2358,12 +2358,12 @@ namespace ts {
 
     // @api
    shared<ClassExpression> Factory::createClassExpression(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
-            optional<NodeArray> typeParameters,
-            optional<NodeArray> heritageClauses,
-            NodeArray members
+            sharedOpt<NodeArray> typeParameters,
+            sharedOpt<NodeArray> heritageClauses,
+            shared<NodeArray> members
     ) {
         auto node = createBaseClassLikeDeclaration<ClassExpression>(
                 SyntaxKind::ClassExpression,
@@ -2381,12 +2381,12 @@ namespace ts {
 //        // @api
 //        function updateClassExpression(
 //            node: ClassExpression,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
-//            NodeArray members
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
+//            shared<NodeArray> members
 //        ) {
 //            return node->decorators != decorators
 //                || node->modifiers != modifiers
@@ -2404,7 +2404,7 @@ namespace ts {
     }
 
     // @api
-    shared<ExpressionWithTypeArguments> Factory::createExpressionWithTypeArguments(shared<Expression> expression, optional<NodeArray> typeArguments) {
+    shared<ExpressionWithTypeArguments> Factory::createExpressionWithTypeArguments(shared<Expression> expression, sharedOpt<NodeArray> typeArguments) {
         auto node = createBaseNode<ExpressionWithTypeArguments>(SyntaxKind::ExpressionWithTypeArguments);
         node->expression = parenthesizer.parenthesizeLeftSideOfAccess(expression);
         if (typeArguments) node->typeArguments = parenthesizer.parenthesizeTypeArguments(typeArguments);
@@ -2416,7 +2416,7 @@ namespace ts {
     }
 
 //        // @api
-//        function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, shared<Expression> expression, optional<NodeArray> typeArguments) {
+//        function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, shared<Expression> expression, sharedOpt<NodeArray> typeArguments) {
 //            return node->expression != expression
 //                || node->typeArguments != typeArguments
 //                ? update(createExpressionWithTypeArguments(expression, typeArguments), node)
@@ -2544,7 +2544,7 @@ namespace ts {
     //
 
     // @api
-    shared<Block> Factory::createBlock(NodeArray statements, bool multiLine) {
+    shared<Block> Factory::createBlock(shared<NodeArray> statements, bool multiLine) {
         auto node = createBaseNode<Block>(SyntaxKind::Block);
         node->statements = createNodeArray(statements);
         node->multiLine = multiLine;
@@ -2553,7 +2553,7 @@ namespace ts {
     }
 
     // @api
-   shared<VariableDeclarationList> Factory::createVariableDeclarationList(NodeArray declarations, int flags) {
+   shared<VariableDeclarationList> Factory::createVariableDeclarationList(shared<NodeArray> declarations, int flags) {
         auto node = createBaseNode<VariableDeclarationList>(SyntaxKind::VariableDeclarationList);
         node->flags |= flags & (int) NodeFlags::BlockScoped;
         node->declarations = declarations;
@@ -2580,8 +2580,8 @@ namespace ts {
 //        }
 
     // @api
-   shared<VariableStatement> Factory::createVariableStatement(optional<NodeArray> modifiers, variant<shared<VariableDeclarationList>, vector<shared<VariableDeclaration>>> declarationList) {
-        auto node = createBaseDeclaration<VariableStatement>(SyntaxKind::VariableStatement, /*decorators*/ {}, modifiers);
+   shared<VariableStatement> Factory::createVariableStatement(sharedOpt<NodeArray> modifiers, variant<shared<VariableDeclarationList>, vector<shared<VariableDeclaration>>> declarationList) {
+        auto node = createBaseDeclaration<VariableStatement>(SyntaxKind::VariableStatement, /*decorators*/ nullptr, modifiers);
 
         if (holds_alternative<shared<VariableDeclarationList>>(declarationList)) {
             node->declarationList = get<shared<VariableDeclarationList>>(declarationList);
@@ -2597,7 +2597,7 @@ namespace ts {
     }
 
 //        // @api
-//        function updateVariableStatement(node: VariableStatement, optional<NodeArray> modifiers, declarationList: VariableDeclarationList) {
+//        function updateVariableStatement(node: VariableStatement, sharedOpt<NodeArray> modifiers, declarationList: VariableDeclarationList) {
 //            return node->modifiers != modifiers
 //                || node->declarationList != declarationList
 //                ? update(createVariableStatement(modifiers, declarationList), node)
@@ -2933,8 +2933,8 @@ namespace ts {
    shared<VariableDeclaration> Factory::createVariableDeclaration(NameType name, sharedOpt<ExclamationToken> exclamationToken, sharedOpt<TypeNode> type, sharedOpt<Expression> initializer) {
         auto node = createBaseVariableLikeDeclaration<VariableDeclaration>(
                 SyntaxKind::VariableDeclaration,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 name,
                 type,
                 initializer ? parenthesizer.parenthesizeExpressionForDisallowedComma(initializer) : nullptr
@@ -2967,12 +2967,12 @@ namespace ts {
 
     // @api
    shared<FunctionDeclaration> Factory::createFunctionDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             sharedOpt<AsteriskToken> asteriskToken,
             NameType name,
-            optional<NodeArray> typeParameters,
-            NodeArray parameters,
+            sharedOpt<NodeArray> typeParameters,
+            shared<NodeArray> parameters,
             sharedOpt<TypeNode> type,
             sharedOpt<Block> body
     ) {
@@ -3009,12 +3009,12 @@ namespace ts {
 //        // @api
 //        function updateFunctionDeclaration(
 //            node: FunctionDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            sharedOpt<AsteriskToken> asteriskToken,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //           sharedOpt<Block> body
 //        ) {
@@ -3032,12 +3032,12 @@ namespace ts {
 //
     // @api
    shared<ClassDeclaration> Factory::createClassDeclaration(
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
+            sharedOpt<NodeArray> decorators,
+            sharedOpt<NodeArray> modifiers,
             NameType name,
-            optional<NodeArray> typeParameters,
-            optional<NodeArray> heritageClauses,
-            NodeArray members
+            sharedOpt<NodeArray> typeParameters,
+            sharedOpt<NodeArray> heritageClauses,
+            shared<NodeArray> members
     ) {
         auto node = createBaseClassLikeDeclaration<ClassDeclaration>(
                 SyntaxKind::ClassDeclaration,
@@ -3062,12 +3062,12 @@ namespace ts {
 //        // @api
 //        function updateClassDeclaration(
 //            node: ClassDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
-//            NodeArray members
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
+//            shared<NodeArray> members
 //        ) {
 //            return node->decorators != decorators
 //                || node->modifiers != modifiers
@@ -3081,11 +3081,11 @@ namespace ts {
 //
 //        // @api
 //        function createInterfaceDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: string | Identifier,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
 //            members: readonly TypeElement[]
 //        ) {
 //            auto node = createBaseInterfaceOrClassLikeDeclaration<InterfaceDeclaration>(
@@ -3104,11 +3104,11 @@ namespace ts {
 //        // @api
 //        function updateInterfaceDeclaration(
 //            node: InterfaceDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
 //            members: readonly TypeElement[]
 //        ) {
 //            return node->decorators != decorators
@@ -3123,10 +3123,10 @@ namespace ts {
 //
 //        // @api
 //        function createTypeAliasDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: string | Identifier,
-//            optional<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> typeParameters,
 //            shared<TypeNode> type
 //        ) {
 //            auto node = createBaseGenericNamedDeclaration<TypeAliasDeclaration>(
@@ -3144,10 +3144,10 @@ namespace ts {
 //        // @api
 //        function updateTypeAliasDeclaration(
 //            node: TypeAliasDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier,
-//            optional<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> typeParameters,
 //            shared<TypeNode> type
 //        ) {
 //            return node->decorators != decorators
@@ -3161,8 +3161,8 @@ namespace ts {
 //
 //        // @api
 //        function createEnumDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: string | Identifier,
 //            members: readonly EnumMember[]
 //        ) {
@@ -3183,8 +3183,8 @@ namespace ts {
 //        // @api
 //        function updateEnumDeclaration(
 //            node: EnumDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier,
 //            members: readonly EnumMember[]) {
 //            return node->decorators != decorators
@@ -3197,8 +3197,8 @@ namespace ts {
 //
 //        // @api
 //        function createModuleDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: ModuleName,
 //            body: ModuleBody | undefined,
 //            flags = NodeFlags::None
@@ -3227,8 +3227,8 @@ namespace ts {
 //        // @api
 //        function updateModuleDeclaration(
 //            node: ModuleDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: ModuleName,
 //            body: ModuleBody | undefined
 //        ) {
@@ -3274,8 +3274,8 @@ namespace ts {
 //        function createNamespaceExportDeclaration(name: string | Identifier) {
 //            auto node = createBaseNamedDeclaration<NamespaceExportDeclaration>(
 //                SyntaxKind::NamespaceExportDeclaration,
-//                /*decorators*/ {},
-//                /*modifiers*/ {},
+//                /*decorators*/ nullptr,
+//                /*modifiers*/ nullptr,
 //                name
 //            );
 //            node->transformFlags = (int)TransformFlags::ContainsTypeScript;
@@ -3291,8 +3291,8 @@ namespace ts {
 //
 //        // @api
 //        function createImportEqualsDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            name: string | Identifier,
 //            moduleReference: ModuleReference
@@ -3314,8 +3314,8 @@ namespace ts {
 //        // @api
 //        function updateImportEqualsDeclaration(
 //            node: ImportEqualsDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            name: Identifier,
 //            moduleReference: ModuleReference
@@ -3331,8 +3331,8 @@ namespace ts {
 //
 //        // @api
 //        function createImportDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            importClause: ImportClause | undefined,
 //            moduleSpecifier: Expression,
 //            assertClause: AssertClause | undefined
@@ -3355,8 +3355,8 @@ namespace ts {
 //        // @api
 //        function updateImportDeclaration(
 //            node: ImportDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            importClause: ImportClause | undefined,
 //            moduleSpecifier: Expression,
 //            assertClause: AssertClause | undefined
@@ -3396,7 +3396,7 @@ namespace ts {
 //        }
 //
     // @api
-   shared<AssertClause> Factory::createAssertClause(NodeArray elements, bool multiLine) {
+   shared<AssertClause> Factory::createAssertClause(shared<NodeArray> elements, bool multiLine) {
         auto node = createBaseNode<AssertClause>(SyntaxKind::AssertClause);
         node->elements = createNodeArray(elements);
         node->multiLine = multiLine;
@@ -3519,8 +3519,8 @@ namespace ts {
 //
 //        // @api
 //        function createExportAssignment(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isExportEquals: boolean | undefined,
 //            shared<Expression> expression
 //        ) {
@@ -3541,8 +3541,8 @@ namespace ts {
 //        // @api
 //        function updateExportAssignment(
 //            node: ExportAssignment,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            shared<Expression> expression
 //        ) {
 //            return node->decorators != decorators
@@ -3554,8 +3554,8 @@ namespace ts {
 //
 //        // @api
 //        function createExportDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            exportClause: NamedExportBindings | undefined,
 //            moduleSpecifier?: Expression,
@@ -3580,8 +3580,8 @@ namespace ts {
 //        // @api
 //        function updateExportDeclaration(
 //            node: ExportDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            exportClause: NamedExportBindings | undefined,
 //            moduleSpecifier: Expression | undefined,
@@ -3639,7 +3639,7 @@ namespace ts {
     shared<MissingDeclaration> Factory::createMissingDeclaration() {
         auto node = createBaseDeclaration<MissingDeclaration>(
                 SyntaxKind::MissingDeclaration,
-                /*decorators*/ {},
+                /*decorators*/ nullptr,
                 /*modifiers*/ {}
         );
         return node;
@@ -3718,11 +3718,11 @@ namespace ts {
 //        }
 //
 //        // @api
-//        function createJSDocFunctionType(NodeArray parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
+//        function createJSDocFunctionType(shared<NodeArray> parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
 //            auto node = createBaseSignatureDeclaration<JSDocFunctionType>(
 //                SyntaxKind::JSDocFunctionType,
-//                /*decorators*/ {},
-//                /*modifiers*/ {},
+//                /*decorators*/ nullptr,
+//                /*modifiers*/ nullptr,
 //                /*name*/ {},
 //                /*typeParameters*/ {},
 //                parameters,
@@ -3732,7 +3732,7 @@ namespace ts {
 //        }
 //
 //        // @api
-//        function updateJSDocFunctionType(node: JSDocFunctionType, NodeArray parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
+//        function updateJSDocFunctionType(node: JSDocFunctionType, shared<NodeArray> parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
 //            return node->parameters != parameters
 //                || node->type != type
 //                ? update(createJSDocFunctionType(parameters, type), node)
@@ -4129,7 +4129,7 @@ namespace ts {
 //        //
 //
 // @api
-    shared<JsxElement> Factory::createJsxElement(shared<JsxOpeningElement> openingElement, NodeArray children, shared<JsxClosingElement> closingElement) {
+    shared<JsxElement> Factory::createJsxElement(shared<JsxOpeningElement> openingElement, shared<NodeArray> children, shared<JsxClosingElement> closingElement) {
         auto node = createBaseNode<JsxElement>(SyntaxKind::JsxElement);
         node->openingElement = openingElement;
         node->children = createNodeArray(children);
@@ -4152,7 +4152,7 @@ namespace ts {
 //        }
 
 // @api
-    shared<JsxSelfClosingElement> Factory::createJsxSelfClosingElement(shared<NodeUnion(JsxTagNameExpression)> tagName, optional<NodeArray> typeArguments, shared<JsxAttributes> attributes) {
+    shared<JsxSelfClosingElement> Factory::createJsxSelfClosingElement(shared<NodeUnion(JsxTagNameExpression)> tagName, sharedOpt<NodeArray> typeArguments, shared<JsxAttributes> attributes) {
         auto node = createBaseNode<JsxSelfClosingElement>(SyntaxKind::JsxSelfClosingElement);
         node->tagName = tagName;
         node->typeArguments = asNodeArray(typeArguments);
@@ -4169,7 +4169,7 @@ namespace ts {
     }
 //
 //        // @api
-//        function updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, optional<NodeArray> typeArguments, attributes: JsxAttributes) {
+//        function updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, sharedOpt<NodeArray> typeArguments, attributes: JsxAttributes) {
 //            return node->tagName != tagName
 //                || node->typeArguments != typeArguments
 //                || node->attributes != attributes
@@ -4178,7 +4178,7 @@ namespace ts {
 //        }
 //
 // @api
-    shared<JsxOpeningElement> Factory::createJsxOpeningElement(shared<NodeUnion(JsxTagNameExpression)> tagName, optional<NodeArray> typeArguments, shared<JsxAttributes> attributes) {
+    shared<JsxOpeningElement> Factory::createJsxOpeningElement(shared<NodeUnion(JsxTagNameExpression)> tagName, sharedOpt<NodeArray> typeArguments, shared<JsxAttributes> attributes) {
         auto node = createBaseNode<JsxOpeningElement>(SyntaxKind::JsxOpeningElement);
         node->tagName = tagName;
         node->typeArguments = asNodeArray(typeArguments);
@@ -4195,7 +4195,7 @@ namespace ts {
     }
 //
 //        // @api
-//        function updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, optional<NodeArray> typeArguments, attributes: JsxAttributes) {
+//        function updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, sharedOpt<NodeArray> typeArguments, attributes: JsxAttributes) {
 //            return node->tagName != tagName
 //                || node->typeArguments != typeArguments
 //                || node->attributes != attributes
@@ -4221,7 +4221,7 @@ namespace ts {
 //        }
 
 // @api
-    shared<JsxFragment> Factory::createJsxFragment(shared<JsxOpeningFragment> openingFragment, NodeArray children, shared<JsxClosingFragment> closingFragment) {
+    shared<JsxFragment> Factory::createJsxFragment(shared<JsxOpeningFragment> openingFragment, shared<NodeArray> children, shared<JsxClosingFragment> closingFragment) {
         auto node = createBaseNode<JsxFragment>(SyntaxKind::JsxFragment);
         node->openingFragment = openingFragment;
         node->children = createNodeArray(children);
@@ -4287,7 +4287,7 @@ namespace ts {
 //        }
 //
 // @api
-    shared<JsxAttributes> Factory::createJsxAttributes(NodeArray properties) {
+    shared<JsxAttributes> Factory::createJsxAttributes(shared<NodeArray> properties) {
         auto node = createBaseNode<JsxAttributes>(SyntaxKind::JsxAttributes);
         node->properties = createNodeArray(properties);
         node->transformFlags |=
@@ -4378,7 +4378,7 @@ namespace ts {
 //        }
 
     // @api
-   shared<HeritageClause> Factory::createHeritageClause(SyntaxKind token, NodeArray types) {
+   shared<HeritageClause> Factory::createHeritageClause(SyntaxKind token, shared<NodeArray> types) {
         auto node = createBaseNode<HeritageClause>(SyntaxKind::HeritageClause);
         node->token = token;
         node->types = createNodeArray(types);
@@ -4439,8 +4439,8 @@ namespace ts {
    shared<PropertyAssignment> Factory::createPropertyAssignment(NameType name, shared<Expression> initializer) {
         auto node = createBaseNamedDeclaration<PropertyAssignment>(
                 SyntaxKind::PropertyAssignment,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 name
         );
         node->initializer = parenthesizer.parenthesizeExpressionForDisallowedComma(initializer);
@@ -4471,8 +4471,8 @@ namespace ts {
    shared<ShorthandPropertyAssignment> Factory::createShorthandPropertyAssignment(NameType name, sharedOpt<Expression> objectAssignmentInitializer) {
         auto node = createBaseNamedDeclaration<ShorthandPropertyAssignment>(
                 SyntaxKind::ShorthandPropertyAssignment,
-                /*decorators*/ {},
-                /*modifiers*/ {},
+                /*decorators*/ nullptr,
+                /*modifiers*/ nullptr,
                 name
         );
         node->objectAssignmentInitializer = objectAssignmentInitializer ? parenthesizer.parenthesizeExpressionForDisallowedComma(objectAssignmentInitializer) : nullptr;
@@ -4859,7 +4859,7 @@ namespace ts {
 //        function createImmediatelyInvokedFunctionExpression(statements: readonly Statement[], param?: ParameterDeclaration, paramValue?: Expression) {
 //            return createCallExpression(
 //                createFunctionExpression(
-//                    /*modifiers*/ {},
+//                    /*modifiers*/ nullptr,
 //                    /*asteriskToken*/ {},
 //                    /*name*/ {},
 //                    /*typeParameters*/ {},
@@ -4877,7 +4877,7 @@ namespace ts {
 //        function createImmediatelyInvokedArrowFunction(statements: readonly Statement[], param?: ParameterDeclaration, paramValue?: Expression) {
 //            return createCallExpression(
 //                createArrowFunction(
-//                    /*modifiers*/ {},
+//                    /*modifiers*/ nullptr,
 //                    /*typeParameters*/ {},
 //                    /*parameters*/ param ? [param] : [],
 //                    /*type*/ {},
@@ -4895,16 +4895,16 @@ namespace ts {
 //
 //        function createExportDefault(shared<Expression> expression) {
 //            return createExportAssignment(
-//                /*decorators*/ {},
-//                /*modifiers*/ {},
+//                /*decorators*/ nullptr,
+//                /*modifiers*/ nullptr,
 //                /*isExportEquals*/ false,
 //                expression);
 //        }
 //
 //        function createExternalModuleExport(exportName: Identifier) {
 //            return createExportDeclaration(
-//                /*decorators*/ {},
-//                /*modifiers*/ {},
+//                /*decorators*/ nullptr,
+//                /*modifiers*/ nullptr,
 //                /*isTypeOnly*/ false,
 //                createNamedExports([
 //                    createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ {}, exportName)
@@ -5162,12 +5162,12 @@ namespace ts {
 //                createParenthesizedExpression(
 //                    createObjectLiteralExpression([
 //                        createSetAccessorDeclaration(
-//                            /*decorators*/ {},
-//                            /*modifiers*/ {},
+//                            /*decorators*/ nullptr,
+//                            /*modifiers*/ nullptr,
 //                            "value",
 //                            [createParameterDeclaration(
-//                                /*decorators*/ {},
-//                                /*modifiers*/ {},
+//                                /*decorators*/ nullptr,
+//                                /*modifiers*/ nullptr,
 //                                /*dotDotDotToken*/ {},
 //                                paramName,
 //                                /*questionToken*/ {},
@@ -5387,7 +5387,7 @@ namespace ts {
 //        }
 //
 //        /**
-//         * Lifts a NodeArray containing only Statement nodes to a block.
+//         * Lifts a shared<NodeArray> containing only Statement nodes to a block.
 //         *
 //         * @param nodes The NodeArray.
 //         */
diff --git a/src/factory.h b/src/factory.h
index 52fd4ca..3c07a92 100644
--- a/src/factory.h
+++ b/src/factory.h
@@ -2,6 +2,7 @@
 
 #include <utility>
 
+#include "Tracy.hpp"
 #include "types.h"
 #include "utilities.h"
 #include "scanner.h"
@@ -40,31 +41,31 @@ namespace ts {
 
         int propagateIdentifierNameFlags(shared<Node> node);
 
-        int propagateChildrenFlags(optional<NodeArray> children);
+        int propagateChildrenFlags(sharedOpt<NodeArray> children);
 
-        void aggregateChildrenFlags(NodeArray &children);
+        void aggregateChildrenFlags(shared<NodeArray> &children);
 
-        NodeArray createNodeArray(optional<NodeArray> elements, optional<bool> hasTrailingComma = {});
+        shared<NodeArray> createNodeArray(sharedOpt<NodeArray> elements, optional<bool> hasTrailingComma = {});
 
-        optional<NodeArray> asNodeArray(optional<NodeArray> array);
+        sharedOpt<NodeArray> asNodeArray(sharedOpt<NodeArray> elements);
 
         template<class T>
-        NodeArray asNodeArray(vector<shared<T>> array) {
-            NodeArray nodeArray;
-            for (auto node: array) nodeArray.list.push_back(node);
+        inline shared<NodeArray> asNodeArray(const vector<shared<T>> &array) {
+            auto nodeArray = make_shared<NodeArray>();
+            for (auto node: array) nodeArray->list.push_back(node);
             return nodeArray;
         }
 
-        template<class T>
-        optional<NodeArray> asNodeArray(optional<vector<shared<T>>> array) {
-            if (!array) return nullopt;
-
-            return asNodeArray(*array);
-        }
+//        template<class T>
+//        sharedOpt<NodeArray> asNodeArray(optional<vector<shared<T>>> &array) {
+//            if (!array) return nullptr;
+//
+//            return asNodeArray(*array);
+//        }
 
         // @api
         template<class T>
-        NodeArray createNodeArray(vector<shared<T>> elements, optional<bool> hasTrailingComma = {}) {
+        shared<NodeArray> createNodeArray(const vector<shared<T>> &elements, optional<bool> hasTrailingComma = {}) {
             // Since the element list of a node array is typically created by starting with an empty array and
             // repeatedly calling push(), the list may not have the optimal memory layout. We invoke slice() for
             // small arrays (1 to 4 elements) to give the VM a chance to allocate an optimal representation.
@@ -217,8 +218,8 @@ namespace ts {
         template<class T>
         shared<T> createBaseDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers
         ) {
             auto node = createBaseNode<T>(kind);
             node->decorators = asNodeArray(decorators);
@@ -257,8 +258,8 @@ namespace ts {
         template<class T>
         shared<T> createBaseNamedDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 optional<NameType> _name
         ) {
             auto node = createBaseDeclaration<T>(
@@ -295,10 +296,10 @@ namespace ts {
         template<class T>
         shared<T> createBaseGenericNamedDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters
+                sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters
         ) {
             auto node = createBaseNamedDeclaration<T>(
                     kind,
@@ -315,11 +316,11 @@ namespace ts {
         template<class T>
         shared<T> createBaseSignatureDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters,
-                optional<NodeTypeArray(ParameterDeclaration)> parameters,
+                sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters,
+                sharedOpt<NodeTypeArray(ParameterDeclaration)> parameters,
                 sharedOpt<TypeNode> type
         ) {
             auto node = createBaseGenericNamedDeclaration<T>(
@@ -347,11 +348,11 @@ namespace ts {
         template<class T>
         shared<T> createBaseFunctionLikeDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                optional<NodeArray> parameters,
+                sharedOpt<NodeArray> typeParameters,
+                sharedOpt<NodeArray> parameters,
                 sharedOpt<TypeNode> type,
                 decltype(declval<T>().body) body
         ) {
@@ -380,11 +381,11 @@ namespace ts {
         template<class T>
         shared<T> createBaseInterfaceOrClassLikeDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                optional<NodeArray> heritageClauses
+                sharedOpt<NodeArray> typeParameters,
+                sharedOpt<NodeArray> heritageClauses
         ) {
             auto node = createBaseGenericNamedDeclaration<T>(
                     kind,
@@ -401,12 +402,12 @@ namespace ts {
         template<class T>
         shared<T> createBaseClassLikeDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                optional<NodeArray> heritageClauses,
-                NodeArray members
+                sharedOpt<NodeArray> typeParameters,
+                sharedOpt<NodeArray> heritageClauses,
+                shared<NodeArray> members
         ) {
             auto node = createBaseInterfaceOrClassLikeDeclaration<T>(
                     kind,
@@ -424,8 +425,8 @@ namespace ts {
         template<class T>
         shared<T> createBaseBindingLikeDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 optional<NameType> name,
                 sharedOpt<Expression> initializer
         ) {
@@ -443,8 +444,8 @@ namespace ts {
         template<class T>
         shared<T> createBaseVariableLikeDeclaration(
                 SyntaxKind kind,
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 optional<NameType> name,
                 sharedOpt<TypeNode> type,
                 sharedOpt<Expression> initializer
@@ -490,7 +491,7 @@ namespace ts {
         shared<Identifier> createBaseGeneratedIdentifier(string text, GeneratedIdentifierFlags autoGenerateFlags);
 
         // @api
-        shared<Identifier> createIdentifier(string text, optional<NodeArray> typeArguments = {}, optional<SyntaxKind> originalKeywordKind = {});
+        shared<Identifier> createIdentifier(string text, sharedOpt<NodeArray> typeArguments = {}, optional<SyntaxKind> originalKeywordKind = {});
 //
 //        // @api
 //        function updateIdentifier(node: Identifier, typeArguments?: NodeArray<TypeNode | TypeParameterDeclaration> | undefined): Identifier {
@@ -602,18 +603,18 @@ namespace ts {
 //        //
 //
 //        // @api
-//        function createTypeParameterDeclaration(optional<NodeArray> modifiers, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
+//        function createTypeParameterDeclaration(sharedOpt<NodeArray> modifiers, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
 //        /** @deprecated */
 //        function createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
        shared<TypeParameterDeclaration> createTypeParameterDeclaration(
-                optional<variant<NodeArray, shared<Node>, string>> modifiersOrName,
+                optional<variant<shared<NodeArray>, shared<Node>, string>> modifiersOrName,
                 optional<variant<shared<TypeNode>, shared<Identifier>, string>> nameOrConstraint,
                 sharedOpt<TypeNode> constraintOrDefault,
                 sharedOpt<TypeNode> defaultType = nullptr
         );
 
 //        // @api
-//        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, optional<NodeArray> modifiers, name: Identifier, constraint: TypeNode | undefined, defaultsharedOpt<TypeNode> type): TypeParameterDeclaration;
+//        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, sharedOpt<NodeArray> modifiers, name: Identifier, constraint: TypeNode | undefined, defaultsharedOpt<TypeNode> type): TypeParameterDeclaration;
 //        /** @deprecated */
 //        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultsharedOpt<TypeNode> type): TypeParameterDeclaration;
 //        function updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiersOrName: readonly Modifier[] | Identifier | undefined, nameOrConstraint: Identifier | TypeNode | undefined, constraintOrDefault: TypeNode | undefined, defaultType?: TypeNode | undefined) {
@@ -640,8 +641,8 @@ namespace ts {
 
         // @api
         shared<ParameterDeclaration> createParameterDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 sharedOpt<DotDotDotToken> dotDotDotToken = nullptr,
                 NameType name = "",
                 sharedOpt<QuestionToken> questionToken = nullptr,
@@ -652,8 +653,8 @@ namespace ts {
 //        // @api
 //        function updateParameterDeclaration(
 //            node: ParameterDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            dotDotDotToken: DotDotDotToken | undefined,
 //            name: string | BindingName,
 //            sharedOpt<QuestionToken> questionToken,
@@ -687,7 +688,7 @@ namespace ts {
 //
         // @api
         shared<PropertySignature> createPropertySignature(
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
                 sharedOpt<QuestionToken> questionToken,
                 sharedOpt<TypeNode> type
@@ -696,7 +697,7 @@ namespace ts {
 //        // @api
 //        function updatePropertySignature(
 //            node: PropertySignature,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
 //            sharedOpt<QuestionToken> questionToken,
 //            sharedOpt<TypeNode> type
@@ -711,8 +712,8 @@ namespace ts {
 
         // @api
         shared<PropertyDeclaration> createPropertyDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
                 sharedOpt<Node> questionOrExclamationToken,
                 sharedOpt<TypeNode> type,
@@ -722,8 +723,8 @@ namespace ts {
 //        // @api
 //        function updatePropertyDeclaration(
 //            node: PropertyDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            NameType name,
 //            questionOrExclamationToken: QuestionToken | ExclamationToken | undefined,
 //            sharedOpt<TypeNode> type,
@@ -742,18 +743,18 @@ namespace ts {
 //
         // @api
         shared<MethodSignature> createMethodSignature(
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
                 sharedOpt<QuestionToken> questionToken,
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type
         );
 
 //        // @api
 //        function updateMethodSignature(
 //            node: MethodSignature,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
 //            sharedOpt<QuestionToken> questionToken,
 //            typeParameters: NodeArray<TypeParameterDeclaration> | undefined,
@@ -772,13 +773,13 @@ namespace ts {
 //
         // @api
         shared<MethodDeclaration> createMethodDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 sharedOpt<AsteriskToken> asteriskToken,
                 NameType name,
                 sharedOpt<QuestionToken> questionToken,
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type,
                 sharedOpt<Block> body
         );
@@ -786,13 +787,13 @@ namespace ts {
 //        // @api
 //        function updateMethodDeclaration(
 //            node: MethodDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            sharedOpt<AsteriskToken> asteriskToken,
 //            name: PropertyName,
 //            sharedOpt<QuestionToken> questionToken,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //           sharedOpt<Block> body
 //        ) {
@@ -811,16 +812,16 @@ namespace ts {
 //
         // @api
         shared<ClassStaticBlockDeclaration> createClassStaticBlockDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 shared<Block> body
         );
 //
 //        // @api
 //        function updateClassStaticBlockDeclaration(
 //            node: ClassStaticBlockDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            shared<Block> block
 //        ): ClassStaticBlockDeclaration {
 //            return node->decorators != decorators
@@ -832,18 +833,18 @@ namespace ts {
 
         // @api
         shared<ConstructorDeclaration> createConstructorDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
-                NodeArray parameters,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
+                shared<NodeArray> parameters,
                 sharedOpt<Block> body
         );
 
 //        // @api
 //        function updateConstructorDeclaration(
 //            node: ConstructorDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
+//            shared<NodeArray> parameters,
 //           sharedOpt<Block> body
 //        ) {
 //            return node->decorators != decorators
@@ -856,10 +857,10 @@ namespace ts {
 //
         // @api
         shared<GetAccessorDeclaration> createGetAccessorDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                NodeArray parameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type,
                 sharedOpt<Block> body
         );
@@ -867,10 +868,10 @@ namespace ts {
 //        // @api
 //        function updateGetAccessorDeclaration(
 //            node: GetAccessorDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
-//            NodeArray parameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //           sharedOpt<Block> body
 //        ) {
@@ -886,20 +887,20 @@ namespace ts {
 
         // @api
         shared<SetAccessorDeclaration> createSetAccessorDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                NodeArray parameters,
+                shared<NodeArray> parameters,
                 sharedOpt<Block> body
         );
 
 //        // @api
 //        function updateSetAccessorDeclaration(
 //            node: SetAccessorDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: PropertyName,
-//            NodeArray parameters,
+//            shared<NodeArray> parameters,
 //           sharedOpt<Block> body
 //        ) {
 //            return node->decorators != decorators
@@ -913,8 +914,8 @@ namespace ts {
 //
         // @api
         shared<CallSignatureDeclaration> createCallSignature(
-                optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters,
-                NodeTypeArray(ParameterDeclaration) parameters,
+                sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters,
+                shared<NodeTypeArray(ParameterDeclaration)> parameters,
                 sharedOpt<TypeNode> type
         );
 
@@ -934,8 +935,8 @@ namespace ts {
 //
         // @api
         shared<ConstructSignatureDeclaration> createConstructSignature(
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type
         );
 //
@@ -955,18 +956,18 @@ namespace ts {
 //
         // @api
         shared<IndexSignatureDeclaration> createIndexSignature(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
-                NodeArray parameters,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type
         );
 
 //        // @api
 //        function updateIndexSignature(
 //            node: IndexSignatureDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
+//            shared<NodeArray> parameters,
 //            shared<TypeNode> type
 //        ) {
 //            return node->parameters != parameters
@@ -1010,7 +1011,7 @@ namespace ts {
 //        }
 
         // @api
-        shared<TypeReferenceNode> createTypeReferenceNode(NameType typeName, optional<NodeArray> typeArguments);
+        shared<TypeReferenceNode> createTypeReferenceNode(NameType typeName, sharedOpt<NodeArray> typeArguments);
 
 //        // @api
 //        function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined) {
@@ -1022,8 +1023,8 @@ namespace ts {
 
         // @api
         shared<FunctionTypeNode> createFunctionTypeNode(
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type
         );
 
@@ -1049,19 +1050,19 @@ namespace ts {
 //        }
 
         shared<ConstructorTypeNode> createConstructorTypeNode1(
-                optional<NodeArray> modifiers,
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> modifiers,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type
         );
 
 //        /** @deprecated */
 //        function createConstructorTypeNode2(
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type
 //        ): ConstructorTypeNode {
-//            return createConstructorTypeNode1(/*modifiers*/ {}, typeParameters, parameters, type);
+//            return createConstructorTypeNode1(/*modifiers*/ nullptr, typeParameters, parameters, type);
 //        }
 //
 //        // @api
@@ -1073,7 +1074,7 @@ namespace ts {
 //
 //        function updateConstructorTypeNode1(
 //            node: ConstructorTypeNode,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            typeParameters: NodeArray<TypeParameterDeclaration> | undefined,
 //            parameters: NodeArray<ParameterDeclaration>,
 //            sharedOpt<TypeNode> type
@@ -1097,7 +1098,7 @@ namespace ts {
 //        }
 //
         // @api
-        shared<TypeQueryNode> createTypeQueryNode(shared<NodeUnion(EntityName)> exprName, optional<NodeArray> typeArguments);
+        shared<TypeQueryNode> createTypeQueryNode(shared<NodeUnion(EntityName)> exprName, sharedOpt<NodeArray> typeArguments);
 
 //        // @api
 //        function updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName, typeArguments?: readonly TypeNode[]) {
@@ -1108,7 +1109,7 @@ namespace ts {
 //        }
 //
         // @api
-        shared<TypeLiteralNode> createTypeLiteralNode(optional<NodeArray> members);
+        shared<TypeLiteralNode> createTypeLiteralNode(sharedOpt<NodeArray> members);
 //
 //        // @api
 //        function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>) {
@@ -1128,7 +1129,7 @@ namespace ts {
 //        }
 //
         // @api
-        shared<TupleTypeNode> createTupleTypeNode(NodeArray elements);
+        shared<TupleTypeNode> createTupleTypeNode(shared<NodeArray> elements);
 
 //        // @api
 //        function updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]) {
@@ -1176,7 +1177,7 @@ namespace ts {
 //        }
 
         template<class T>
-        shared<T> createUnionOrIntersectionTypeNode(SyntaxKind kind, NodeArray types, function<NodeArray(NodeArray)> parenthesize) {
+        shared<T> createUnionOrIntersectionTypeNode(SyntaxKind kind, shared<NodeArray> types, function<shared<NodeArray>(shared<NodeArray>)> parenthesize) {
             auto node = createBaseNode<T>(kind);
             node->types = createNodeArray(parenthesize(types));
             node->transformFlags = (int) TransformFlags::ContainsTypeScript;
@@ -1190,7 +1191,7 @@ namespace ts {
 //        }
 
         // @api
-        shared<UnionTypeNode> createUnionTypeNode(NodeArray types);
+        shared<UnionTypeNode> createUnionTypeNode(shared<NodeArray> types);
 
 //        // @api
 //        function updateUnionTypeNode(node: UnionTypeNode, types: NodeArray<TypeNode>) {
@@ -1198,7 +1199,7 @@ namespace ts {
 //        }
 
         // @api
-        shared<IntersectionTypeNode> createIntersectionTypeNode(NodeArray types);
+        shared<IntersectionTypeNode> createIntersectionTypeNode(shared<NodeArray> types);
 
 //        // @api
 //        function updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray<TypeNode>) {
@@ -1229,7 +1230,7 @@ namespace ts {
 //        }
 
         // @api
-        shared<TemplateLiteralTypeNode> createTemplateLiteralType(shared<TemplateHead> head, NodeArray templateSpans);
+        shared<TemplateLiteralTypeNode> createTemplateLiteralType(shared<TemplateHead> head, shared<NodeArray> templateSpans);
 
 //        // @api
 //        function updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]) {
@@ -1245,14 +1246,14 @@ namespace ts {
         shared<ImportTypeNode> createImportTypeNode(
                 shared<TypeNode> argument,
                 optional<variant<shared<NodeUnion(EntityName)>, shared<ImportTypeAssertionContainer>>> qualifierOrAssertions,
-                optional<variant<shared<NodeUnion(EntityName)>, NodeArray>> typeArgumentsOrQualifier,
-                optional<variant<bool, NodeArray>> isTypeOfOrTypeArguments,
+                optional<variant<shared<NodeUnion(EntityName)>, shared<NodeArray>>> typeArgumentsOrQualifier,
+                optional<variant<bool, shared<NodeArray>>> isTypeOfOrTypeArguments,
                 optional<bool> isTypeOf
         );
 
 //        // @api
-//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, optional<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
-//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, optional<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
+//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, sharedOpt<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
+//        function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, sharedOpt<NodeArray> typeArguments, isTypeOf?: boolean | undefined): ImportTypeNode;
 //        function updateImportTypeNode(
 //            node: ImportTypeNode,
 //            argument: TypeNode,
@@ -1317,11 +1318,11 @@ namespace ts {
                 sharedOpt<TypeNode> nameType,
                 sharedOpt<Node> questionToken, //: QuestionToken | PlusToken | MinusToken | undefined,
                 sharedOpt<TypeNode> type,
-                optional<NodeArray> members
+                sharedOpt<NodeArray> members
         );
 
 //        // @api
-//        function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, namesharedOpt<TypeNode> type, questionToken: QuestionToken | PlusToken | MinusToken | undefined, sharedOpt<TypeNode> type, optional<NodeArray> members): MappedTypeNode {
+//        function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, namesharedOpt<TypeNode> type, questionToken: QuestionToken | PlusToken | MinusToken | undefined, sharedOpt<TypeNode> type, sharedOpt<NodeArray> members): MappedTypeNode {
 //            return node->readonlyToken != readonlyToken
 //                || node->typeParameter != typeParameter
 //                || node->nameType != nameType
@@ -1347,7 +1348,7 @@ namespace ts {
 //        //
 //
         // @api
-        shared<ObjectBindingPattern> createObjectBindingPattern(NodeArray elements);
+        shared<ObjectBindingPattern> createObjectBindingPattern(shared<NodeArray> elements);
 
 //        // @api
 //        function updateObjectBindingPattern(node: ObjectBindingPattern, elements: readonly BindingElement[]) {
@@ -1357,7 +1358,7 @@ namespace ts {
 //        }
 //
         // @api
-        shared<ArrayBindingPattern> createArrayBindingPattern(NodeArray elements);
+        shared<ArrayBindingPattern> createArrayBindingPattern(shared<NodeArray> elements);
 
 //        // @api
 //        function updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]) {
@@ -1390,13 +1391,14 @@ namespace ts {
 
         template<typename T>
         shared<T> createBaseExpression(SyntaxKind kind) {
+            ZoneScoped;
             auto node = createBaseNode<T>(kind);
             // the following properties are commonly set by the checker/binder
             return node;
         }
 
         // @api
-        shared<ArrayLiteralExpression> createArrayLiteralExpression(optional<NodeArray> elements, bool multiLine);
+        shared<ArrayLiteralExpression> createArrayLiteralExpression(sharedOpt<NodeArray> elements, bool multiLine);
 
 //        // @api
 //        function updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]) {
@@ -1406,7 +1408,7 @@ namespace ts {
 //        }
 
         // @api
-        shared<ObjectLiteralExpression> createObjectLiteralExpression(optional<NodeArray> properties, bool multiLine);
+        shared<ObjectLiteralExpression> createObjectLiteralExpression(sharedOpt<NodeArray> properties, bool multiLine);
 
 //        // @api
 //        function updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]) {
@@ -1475,22 +1477,22 @@ namespace ts {
 //        }
 //
         // @api
-        shared<CallExpression> createCallExpression(shared<Expression> expression, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray);
+        shared<CallExpression> createCallExpression(shared<Expression> expression, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray);
 
         // @api
-        shared<CallChain> createCallChain(shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray);
+        shared<CallChain> createCallChain(shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray);
 
         // @api
-        shared<CallChain> updateCallChain(shared<CallChain> node, shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, optional<NodeArray> typeArguments, NodeArray argumentsArray);
+        shared<CallChain> updateCallChain(shared<CallChain> node, shared<Expression> expression, sharedOpt<QuestionDotToken> questionDotToken, sharedOpt<NodeArray> typeArguments, shared<NodeArray> argumentsArray);
 
         // @api
-        shared<CallExpression> updateCallExpression(shared<CallExpression> node, shared<Expression> expression, optional<NodeArray> typeArguments, NodeArray argumentsArray);
+        shared<CallExpression> updateCallExpression(shared<CallExpression> node, shared<Expression> expression, sharedOpt<NodeArray> typeArguments, shared<NodeArray> argumentsArray);
 
         // @api
-        shared<NewExpression> createNewExpression(shared<Expression> expression, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray);
+        shared<NewExpression> createNewExpression(shared<Expression> expression, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray);
 
 //        // @api
-//        function updateNewExpression(node: NewExpression, shared<Expression> expression, optional<NodeArray> typeArguments, optional<NodeArray> argumentsArray) {
+//        function updateNewExpression(node: NewExpression, shared<Expression> expression, sharedOpt<NodeArray> typeArguments, sharedOpt<NodeArray> argumentsArray) {
 //            return node->expression != expression
 //                || node->typeArguments != typeArguments
 //                || node->arguments != argumentsArray
@@ -1499,10 +1501,10 @@ namespace ts {
 //        }
 
         // @api
-        shared<TaggedTemplateExpression> createTaggedTemplateExpression(shared<Expression> tag, optional<NodeArray> typeArguments, shared<NodeUnion(TemplateLiteral)> templateLiteral);
+        shared<TaggedTemplateExpression> createTaggedTemplateExpression(shared<Expression> tag, sharedOpt<NodeArray> typeArguments, shared<NodeUnion(TemplateLiteral)> templateLiteral);
 //
 //        // @api
-//        function updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, optional<NodeArray> typeArguments, template: TemplateLiteral) {
+//        function updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, sharedOpt<NodeArray> typeArguments, template: TemplateLiteral) {
 //            return node->tag != tag
 //                || node->typeArguments != typeArguments
 //                || node->template != template
@@ -1524,11 +1526,11 @@ namespace ts {
 
         // @api
         shared<FunctionExpression> createFunctionExpression(
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> modifiers,
                 sharedOpt<AsteriskToken> asteriskToken,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                optional<NodeArray> parameters,
+                sharedOpt<NodeArray> typeParameters,
+                sharedOpt<NodeArray> parameters,
                 sharedOpt<TypeNode> type,
                 shared<Block> body
         );
@@ -1536,11 +1538,11 @@ namespace ts {
 //        // @api
 //        function updateFunctionExpression(
 //            node: FunctionExpression,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> modifiers,
 //            sharedOpt<AsteriskToken> asteriskToken,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //            shared<Block> block
 //        ) {
@@ -1556,9 +1558,9 @@ namespace ts {
 //        }
         // @api
         shared<ArrowFunction> createArrowFunction(
-                optional<NodeArray> modifiers,
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> modifiers,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type,
                 sharedOpt<EqualsGreaterThanToken> equalsGreaterThanToken,
                 shared<NodeUnion(ConciseBody)> body
@@ -1567,9 +1569,9 @@ namespace ts {
 //        // @api
 //        function updateArrowFunction(
 //            node: ArrowFunction,
-//            optional<NodeArray> modifiers,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> modifiers,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //            equalsGreaterThanToken: EqualsGreaterThanToken,
 //            body: ConciseBody
@@ -1699,7 +1701,7 @@ namespace ts {
 //        }
 
         // @api
-        shared<TemplateExpression> createTemplateExpression(shared<TemplateHead> head, NodeArray templateSpans);
+        shared<TemplateExpression> createTemplateExpression(shared<TemplateHead> head, shared<NodeArray> templateSpans);
 
 //        // @api
 //        function updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]) {
@@ -1775,23 +1777,23 @@ namespace ts {
 
         // @api
        shared<ClassExpression> createClassExpression(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                optional<NodeArray> heritageClauses,
-                NodeArray members
+                sharedOpt<NodeArray> typeParameters,
+                sharedOpt<NodeArray> heritageClauses,
+                shared<NodeArray> members
         );
 
 //        // @api
 //        function updateClassExpression(
 //            node: ClassExpression,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
-//            NodeArray members
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
+//            shared<NodeArray> members
 //        ) {
 //            return node->decorators != decorators
 //                || node->modifiers != modifiers
@@ -1807,10 +1809,10 @@ namespace ts {
         shared<OmittedExpression> createOmittedExpression();
 
         // @api
-        shared<ExpressionWithTypeArguments> createExpressionWithTypeArguments(shared<Expression> expression, optional<NodeArray> typeArguments);
+        shared<ExpressionWithTypeArguments> createExpressionWithTypeArguments(shared<Expression> expression, sharedOpt<NodeArray> typeArguments);
 
 //        // @api
-//        function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, shared<Expression> expression, optional<NodeArray> typeArguments) {
+//        function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, shared<Expression> expression, sharedOpt<NodeArray> typeArguments) {
 //            return node->expression != expression
 //                || node->typeArguments != typeArguments
 //                ? update(createExpressionWithTypeArguments(expression, typeArguments), node)
@@ -1868,10 +1870,10 @@ namespace ts {
         //
 
         // @api
-        shared<Block> createBlock(NodeArray statements, bool multiLine);
+        shared<Block> createBlock(shared<NodeArray> statements, bool multiLine);
 
         // @api
-       shared<VariableDeclarationList> createVariableDeclarationList(NodeArray declarations, int flags = (int) NodeFlags::None);
+       shared<VariableDeclarationList> createVariableDeclarationList(shared<NodeArray> declarations, int flags = (int) NodeFlags::None);
 
        shared<VariableDeclarationList> createVariableDeclarationList(vector<shared<VariableDeclaration>> declarations, int flags = (int) NodeFlags::None);
 
@@ -1883,10 +1885,10 @@ namespace ts {
 //        }
 
         // @api
-       shared<VariableStatement> createVariableStatement(optional<NodeArray> modifiers, variant<shared<VariableDeclarationList>, vector<shared<VariableDeclaration>>> declarationList);
+       shared<VariableStatement> createVariableStatement(sharedOpt<NodeArray> modifiers, variant<shared<VariableDeclarationList>, vector<shared<VariableDeclaration>>> declarationList);
 
 //        // @api
-//        function updateVariableStatement(node: VariableStatement, optional<NodeArray> modifiers, declarationList: VariableDeclarationList) {
+//        function updateVariableStatement(node: VariableStatement, sharedOpt<NodeArray> modifiers, declarationList: VariableDeclarationList) {
 //            return node->modifiers != modifiers
 //                || node->declarationList != declarationList
 //                ? update(createVariableStatement(modifiers, declarationList), node)
@@ -2224,12 +2226,12 @@ namespace ts {
 
         // @api
        shared<FunctionDeclaration> createFunctionDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 sharedOpt<AsteriskToken> asteriskToken,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                NodeArray parameters,
+                sharedOpt<NodeArray> typeParameters,
+                shared<NodeArray> parameters,
                 sharedOpt<TypeNode> type,
                 sharedOpt<Block> body
         );
@@ -2237,12 +2239,12 @@ namespace ts {
 //        // @api
 //        function updateFunctionDeclaration(
 //            node: FunctionDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            sharedOpt<AsteriskToken> asteriskToken,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            NodeArray parameters,
+//            sharedOpt<NodeArray> typeParameters,
+//            shared<NodeArray> parameters,
 //            sharedOpt<TypeNode> type,
 //           sharedOpt<Block> body
 //        ) {
@@ -2260,23 +2262,23 @@ namespace ts {
 //
         // @api
        shared<ClassDeclaration> createClassDeclaration(
-                optional<NodeArray> decorators,
-                optional<NodeArray> modifiers,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
                 NameType name,
-                optional<NodeArray> typeParameters,
-                optional<NodeArray> heritageClauses,
-                NodeArray members
+                sharedOpt<NodeArray> typeParameters,
+                sharedOpt<NodeArray> heritageClauses,
+                shared<NodeArray> members
         );
 
 //        // @api
 //        function updateClassDeclaration(
 //            node: ClassDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier | undefined,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
-//            NodeArray members
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
+//            shared<NodeArray> members
 //        ) {
 //            return node->decorators != decorators
 //                || node->modifiers != modifiers
@@ -2290,11 +2292,11 @@ namespace ts {
 //
 //        // @api
 //        function createInterfaceDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: string | Identifier,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
 //            members: readonly TypeElement[]
 //        ) {
 //            auto node = createBaseInterfaceOrClassLikeDeclaration<InterfaceDeclaration>(
@@ -2313,11 +2315,11 @@ namespace ts {
 //        // @api
 //        function updateInterfaceDeclaration(
 //            node: InterfaceDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier,
-//            optional<NodeArray> typeParameters,
-//            optional<NodeArray> heritageClauses,
+//            sharedOpt<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> heritageClauses,
 //            members: readonly TypeElement[]
 //        ) {
 //            return node->decorators != decorators
@@ -2332,10 +2334,10 @@ namespace ts {
 //
 //        // @api
 //        function createTypeAliasDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: string | Identifier,
-//            optional<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> typeParameters,
 //            shared<TypeNode> type
 //        ) {
 //            auto node = createBaseGenericNamedDeclaration<TypeAliasDeclaration>(
@@ -2353,10 +2355,10 @@ namespace ts {
 //        // @api
 //        function updateTypeAliasDeclaration(
 //            node: TypeAliasDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier,
-//            optional<NodeArray> typeParameters,
+//            sharedOpt<NodeArray> typeParameters,
 //            shared<TypeNode> type
 //        ) {
 //            return node->decorators != decorators
@@ -2370,8 +2372,8 @@ namespace ts {
 //
 //        // @api
 //        function createEnumDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: string | Identifier,
 //            members: readonly EnumMember[]
 //        ) {
@@ -2392,8 +2394,8 @@ namespace ts {
 //        // @api
 //        function updateEnumDeclaration(
 //            node: EnumDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: Identifier,
 //            members: readonly EnumMember[]) {
 //            return node->decorators != decorators
@@ -2406,8 +2408,8 @@ namespace ts {
 //
 //        // @api
 //        function createModuleDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: ModuleName,
 //            body: ModuleBody | undefined,
 //            flags = NodeFlags::None
@@ -2436,8 +2438,8 @@ namespace ts {
 //        // @api
 //        function updateModuleDeclaration(
 //            node: ModuleDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            name: ModuleName,
 //            body: ModuleBody | undefined
 //        ) {
@@ -2500,8 +2502,8 @@ namespace ts {
 //
 //        // @api
 //        function createImportEqualsDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            name: string | Identifier,
 //            moduleReference: ModuleReference
@@ -2523,8 +2525,8 @@ namespace ts {
 //        // @api
 //        function updateImportEqualsDeclaration(
 //            node: ImportEqualsDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            name: Identifier,
 //            moduleReference: ModuleReference
@@ -2540,8 +2542,8 @@ namespace ts {
 //
 //        // @api
 //        function createImportDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            importClause: ImportClause | undefined,
 //            moduleSpecifier: Expression,
 //            assertClause: AssertClause | undefined
@@ -2564,8 +2566,8 @@ namespace ts {
 //        // @api
 //        function updateImportDeclaration(
 //            node: ImportDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            importClause: ImportClause | undefined,
 //            moduleSpecifier: Expression,
 //            assertClause: AssertClause | undefined
@@ -2605,7 +2607,7 @@ namespace ts {
 //        }
 //
         // @api
-       shared<AssertClause> createAssertClause(NodeArray elements, bool multiLine);
+       shared<AssertClause> createAssertClause(shared<NodeArray> elements, bool multiLine);
 
 //        // @api
 //        function updateAssertClause(node: AssertClause, elements: readonly AssertEntry[], multiLine?: boolean): AssertClause {
@@ -2711,8 +2713,8 @@ namespace ts {
 //
 //        // @api
 //        function createExportAssignment(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isExportEquals: boolean | undefined,
 //            shared<Expression> expression
 //        ) {
@@ -2733,8 +2735,8 @@ namespace ts {
 //        // @api
 //        function updateExportAssignment(
 //            node: ExportAssignment,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            shared<Expression> expression
 //        ) {
 //            return node->decorators != decorators
@@ -2746,8 +2748,8 @@ namespace ts {
 //
 //        // @api
 //        function createExportDeclaration(
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            exportClause: NamedExportBindings | undefined,
 //            moduleSpecifier?: Expression,
@@ -2772,8 +2774,8 @@ namespace ts {
 //        // @api
 //        function updateExportDeclaration(
 //            node: ExportDeclaration,
-//            optional<NodeArray> decorators,
-//            optional<NodeArray> modifiers,
+//            sharedOpt<NodeArray> decorators,
+//            sharedOpt<NodeArray> modifiers,
 //            isTypeOnly: boolean,
 //            exportClause: NamedExportBindings | undefined,
 //            moduleSpecifier: Expression | undefined,
@@ -2903,7 +2905,7 @@ namespace ts {
 //        }
 //
 //        // @api
-//        function createJSDocFunctionType(NodeArray parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
+//        function createJSDocFunctionType(shared<NodeArray> parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
 //            auto node = createBaseSignatureDeclaration<JSDocFunctionType>(
 //                SyntaxKind::JSDocFunctionType,
 //                /*decorators*/ {},
@@ -2917,7 +2919,7 @@ namespace ts {
 //        }
 //
 //        // @api
-//        function updateJSDocFunctionType(node: JSDocFunctionType, NodeArray parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
+//        function updateJSDocFunctionType(node: JSDocFunctionType, shared<NodeArray> parameters, sharedOpt<TypeNode> type): JSDocFunctionType {
 //            return node->parameters != parameters
 //                || node->type != type
 //                ? update(createJSDocFunctionType(parameters, type), node)
@@ -3314,7 +3316,7 @@ namespace ts {
 //        //
 //
 // @api
-        shared<JsxElement> createJsxElement(shared<JsxOpeningElement> openingElement, NodeArray children, shared<JsxClosingElement> closingElement);
+        shared<JsxElement> createJsxElement(shared<JsxOpeningElement> openingElement, shared<NodeArray> children, shared<JsxClosingElement> closingElement);
 
 //        // @api
 //        function updateJsxElement(node: JsxElement, openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement) {
@@ -3326,10 +3328,10 @@ namespace ts {
 //        }
 
 // @api
-        shared<JsxSelfClosingElement> createJsxSelfClosingElement(shared<NodeUnion(JsxTagNameExpression)> tagName, optional<NodeArray> typeArguments, shared<JsxAttributes> attributes);
+        shared<JsxSelfClosingElement> createJsxSelfClosingElement(shared<NodeUnion(JsxTagNameExpression)> tagName, sharedOpt<NodeArray> typeArguments, shared<JsxAttributes> attributes);
 //
 //        // @api
-//        function updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, optional<NodeArray> typeArguments, attributes: JsxAttributes) {
+//        function updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, sharedOpt<NodeArray> typeArguments, attributes: JsxAttributes) {
 //            return node->tagName != tagName
 //                || node->typeArguments != typeArguments
 //                || node->attributes != attributes
@@ -3338,10 +3340,10 @@ namespace ts {
 //        }
 //
 // @api
-        shared<JsxOpeningElement> createJsxOpeningElement(shared<NodeUnion(JsxTagNameExpression)> tagName, optional<NodeArray> typeArguments, shared<JsxAttributes> attributes);
+        shared<JsxOpeningElement> createJsxOpeningElement(shared<NodeUnion(JsxTagNameExpression)> tagName, sharedOpt<NodeArray> typeArguments, shared<JsxAttributes> attributes);
 //
 //        // @api
-//        function updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, optional<NodeArray> typeArguments, attributes: JsxAttributes) {
+//        function updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, sharedOpt<NodeArray> typeArguments, attributes: JsxAttributes) {
 //            return node->tagName != tagName
 //                || node->typeArguments != typeArguments
 //                || node->attributes != attributes
@@ -3360,7 +3362,7 @@ namespace ts {
 //        }
 
 // @api
-        shared<JsxFragment> createJsxFragment(shared<JsxOpeningFragment> openingFragment, NodeArray children, shared<JsxClosingFragment> closingFragment);
+        shared<JsxFragment> createJsxFragment(shared<JsxOpeningFragment> openingFragment, shared<NodeArray> children, shared<JsxClosingFragment> closingFragment);
 
 //        // @api
 //        function updateJsxFragment(node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment) {
@@ -3398,7 +3400,7 @@ namespace ts {
 //        }
 //
 // @api
-        shared<JsxAttributes> createJsxAttributes(NodeArray properties);
+        shared<JsxAttributes> createJsxAttributes(shared<NodeArray> properties);
 //
 //        // @api
 //        function updateJsxAttributes(node: JsxAttributes, properties: readonly JsxAttributeLike[]) {
@@ -3466,7 +3468,7 @@ namespace ts {
 //        }
 
         // @api
-       shared<HeritageClause> createHeritageClause(SyntaxKind token, NodeArray types);
+       shared<HeritageClause> createHeritageClause(SyntaxKind token, shared<NodeArray> types);
 
 //        // @api
 //        function updateHeritageClause(node: HeritageClause, types: readonly ExpressionWithTypeArguments[]) {
@@ -3581,34 +3583,34 @@ namespace ts {
 //                ? update(createEnumMember(name, initializer), node)
 //                : node;
 //        }
-//
-//        //
-//        // Top-level nodes
-//        //
-//
-//        // @api
-//        function createSourceFile(
-//            statements: readonly Statement[],
-//            endOfFileToken: EndOfFileToken,
-//            flags: NodeFlags
-//        ) {
-//            auto node = basecreateBaseSourceFileNode(SyntaxKind::SourceFile) as Mutable<SourceFile>;
-//            node->statements = createNodeArray(statements);
-//            node->endOfFileToken = endOfFileToken;
-//            node->flags |= flags;
-//            node->fileName = "";
-//            node->text = "";
-//            node->languageVersion = 0;
-//            node->languageVariant = 0;
-//            node->scriptKind = 0;
-//            node->isDeclarationFile = false;
-//            node->hasNoDefaultLib = false;
-//            node->transformFlags |=
-//                propagateChildrenFlags(node->statements) |
-//                propagateChildFlags(node->endOfFileToken);
-//            return node;
-//        }
-//
+
+        //
+        // Top-level nodes
+        //
+
+        // @api
+        shared<SourceFile> createSourceFile(
+            shared<NodeArray> statements,
+            shared<EndOfFileToken> endOfFileToken,
+            int flags
+        ) {
+            auto node = make_shared<SourceFile>();
+            node->statements = createNodeArray(statements);
+            node->endOfFileToken = endOfFileToken;
+            node->flags |= (int)flags;
+            node->fileName = "";
+            node->text = "";
+            node->languageVersion = types::ScriptTarget::ES3;
+            node->languageVariant = types::LanguageVariant::Standard;
+            node->scriptKind = types::ScriptKind::Unknown;
+            node->isDeclarationFile = false;
+            node->hasNoDefaultLib = false;
+            node->transformFlags |=
+                propagateChildrenFlags(node->statements) |
+                propagateChildFlags(node->endOfFileToken);
+            return node;
+        }
+
 //        function cloneSourceFileWithChanges(
 //            source: SourceFile,
 //            statements: readonly Statement[],
@@ -4385,7 +4387,7 @@ namespace ts {
 //        }
 //
 //        /**
-//         * Lifts a NodeArray containing only Statement nodes to a block.
+//         * Lifts a shared<NodeArray> containing only Statement nodes to a block.
 //         *
 //         * @param nodes The NodeArray.
 //         */
diff --git a/src/node_test.cpp b/src/node_test.cpp
index 9508d6c..142db80 100644
--- a/src/node_test.cpp
+++ b/src/node_test.cpp
@@ -57,10 +57,10 @@ namespace ts {
         return ModifierFlags::None;
     }
 
-    int modifiersToFlags(optional<NodeArray> modifiers) {
+    int modifiersToFlags(shared<NodeArray> modifiers) {
         int flags = (int) ModifierFlags::None;
         if (modifiers) {
-            for (auto &modifier: (*modifiers).list) {
+            for (auto &modifier: modifiers->list) {
                 flags |= (int) modifierToFlag(modifier->kind);
             }
         }
@@ -114,19 +114,17 @@ namespace ts {
     }
 
     shared<NodeUnion(PropertyName)> resolveNameToNode(const shared<Node> &node) {
-        auto a = dynamic_pointer_cast<Identifier>(node);
-
         switch (node->kind) {
             case SyntaxKind::Identifier:
-                return dynamic_pointer_cast<Identifier>(node);
+                return reinterpret_pointer_cast<Identifier>(node);
             case SyntaxKind::StringLiteral:
-                return dynamic_pointer_cast<StringLiteral>(node);
+                return reinterpret_pointer_cast<StringLiteral>(node);
             case SyntaxKind::NumericLiteral:
-                return dynamic_pointer_cast<NumericLiteral>(node);
+                return reinterpret_pointer_cast<NumericLiteral>(node);
             case SyntaxKind::ComputedPropertyName:
-                return dynamic_pointer_cast<ComputedPropertyName>(node);
+                return reinterpret_pointer_cast<ComputedPropertyName>(node);
             case SyntaxKind::PrivateIdentifier:
-                return dynamic_pointer_cast<PrivateIdentifier>(node);
+                return reinterpret_pointer_cast<PrivateIdentifier>(node);
         }
 
         throw runtime_error(format("resolveNamToNode with kind %d no valid name property", (int) node->kind));
@@ -141,7 +139,7 @@ namespace ts {
         return false;
     }
 
-    optional<NodeArray> getTypeParameters(shared<Node> node) {
+    sharedOpt<NodeArray> getTypeParameters(shared<Node> node) {
         switch (node->kind) {
             case SyntaxKind::Constructor:
                 return node->to<ConstructorDeclaration>().typeParameters;
@@ -188,9 +186,9 @@ namespace ts {
     string &getEscapedName(const shared<Node> &node) {
         switch (node->kind) {
             case SyntaxKind::Identifier:
-                return dynamic_pointer_cast<Identifier>(node)->escapedText;
+                return reinterpret_pointer_cast<Identifier>(node)->escapedText;
             case SyntaxKind::PrivateIdentifier:
-                return dynamic_pointer_cast<PrivateIdentifier>(node)->escapedText;
+                return reinterpret_pointer_cast<PrivateIdentifier>(node)->escapedText;
         }
 
         throw runtime_error(format("getEscapedName with kind %d no valid", (int) node->kind));
@@ -204,91 +202,90 @@ namespace ts {
         //[x] Check child of DeclarationStatement
         //[x] Check child of FunctionOrConstructorTypeNodeBase
 
-        if (auto v = dynamic_pointer_cast<PropertyAccessEntityNameExpression>(node)) {
-            return resolveNameToNode(v->name);
-        } else if (auto v = dynamic_pointer_cast<NamespaceDeclaration>(node)) {
-            return resolveNameToNode(v->name);
-        } else
-            switch (node->kind) {
-                case SyntaxKind::FunctionType:
-                    return resolveNameToNode(node->to<FunctionTypeNode>().name);
-                case SyntaxKind::ConstructorType:
-                    return resolveNameToNode(node->to<ConstructorTypeNode>().name);
-                case SyntaxKind::PropertyAccessExpression:
-                    return resolveNameToNode(node->to<PropertyAccessExpression>().name);
-                case SyntaxKind::MetaProperty:
-                    return resolveNameToNode(node->to<MetaProperty>().name);
-                case SyntaxKind::ShorthandPropertyAssignment:
-                    return resolveNameToNode(node->to<ShorthandPropertyAssignment>().name);
-                case SyntaxKind::Parameter:
-                    return resolveNameToNode(node->to<ParameterDeclaration>().name);
-                case SyntaxKind::MissingDeclaration:
-                    return resolveNameToNode(node->to<MissingDeclaration>().name);
-                case SyntaxKind::InterfaceDeclaration:
-                    return resolveNameToNode(node->to<InterfaceDeclaration>().name);
-                case SyntaxKind::ClassDeclaration:
-                    return resolveNameToNode(node->to<ClassDeclaration>().name);
-                case SyntaxKind::ClassExpression:
-                    return resolveNameToNode(node->to<ClassExpression>().name);
-                case SyntaxKind::TypeAliasDeclaration:
-                    return resolveNameToNode(node->to<TypeAliasDeclaration>().name);
-                case SyntaxKind::EnumDeclaration:
-                    return resolveNameToNode(node->to<EnumDeclaration>().name);
-                case SyntaxKind::EnumMember:
-                    return resolveNameToNode(node->to<EnumMember>().name);
-                case SyntaxKind::PropertySignature:
-                    return resolveNameToNode(node->to<PropertySignature>().name);
-                case SyntaxKind::ModuleDeclaration:
-                    return resolveNameToNode(node->to<ModuleDeclaration>().name);
-                case SyntaxKind::ImportEqualsDeclaration:
-                    return resolveNameToNode(node->to<ImportEqualsDeclaration>().name);
-                case SyntaxKind::NamespaceImport:
-                    return resolveNameToNode(node->to<NamespaceImport>().name);
-                case SyntaxKind::ImportSpecifier:
-                    return resolveNameToNode(node->to<ImportSpecifier>().name);
-                case SyntaxKind::AssertEntry:
-                    return resolveNameToNode(node->to<AssertEntry>().name);
-                case SyntaxKind::ImportClause:
-                    return resolveNameToNode(node->to<ImportClause>().name);
-                case SyntaxKind::NamespaceExport:
-                    return resolveNameToNode(node->to<NamespaceExport>().name);
-                case SyntaxKind::ExportSpecifier:
-                    return resolveNameToNode(node->to<ExportSpecifier>().name);
-                case SyntaxKind::ExportDeclaration:
-                    return resolveNameToNode(node->to<ExportDeclaration>().name);
-                case SyntaxKind::NamespaceExportDeclaration:
-                    return resolveNameToNode(node->to<NamespaceExportDeclaration>().name);
-                case SyntaxKind::MethodSignature:
-                    return resolveNameToNode(node->to<MethodSignature>().name);
-                case SyntaxKind::FunctionDeclaration:
-                    return resolveNameToNode(node->to<FunctionDeclaration>().name);
-                case SyntaxKind::MethodDeclaration:
-                    return resolveNameToNode(node->to<MethodDeclaration>().name);
-                case SyntaxKind::GetAccessor:
-                    return resolveNameToNode(node->to<GetAccessorDeclaration>().name);
-                case SyntaxKind::SetAccessor:
-                    return resolveNameToNode(node->to<SetAccessorDeclaration>().name);
-                case SyntaxKind::FunctionExpression:
-                    return resolveNameToNode(node->to<FunctionExpression>().name);
-                case SyntaxKind::NamedTupleMember:
-                    return resolveNameToNode(node->to<NamedTupleMember>().name);
-                case SyntaxKind::JsxAttribute:
-                    return resolveNameToNode(node->to<JsxAttribute>().name);
-                case SyntaxKind::TypeParameter:
-                    return resolveNameToNode(node->to<TypeParameterDeclaration>().name);
-                case SyntaxKind::BindingElement:
-                    return resolveNameToNode(node->to<BindingElement>().name);
-                case SyntaxKind::VariableDeclaration:
-                    return resolveNameToNode(node->to<VariableDeclaration>().name);
-                case SyntaxKind::IndexSignature:
-                    return resolveNameToNode(node->to<IndexSignatureDeclaration>().name);
-                case SyntaxKind::CallSignature:
-                    return resolveNameToNode(node->to<CallSignatureDeclaration>().name);
-                case SyntaxKind::ConstructSignature:
-                    return resolveNameToNode(node->to<ConstructSignatureDeclaration>().name);
-                case SyntaxKind::ExportAssignment:
-                    return resolveNameToNode(node->to<ExportAssignment>().name);
-            }
+        switch (node->kind) {
+            case SyntaxKind::FunctionType:
+                return resolveNameToNode(node->to<FunctionTypeNode>().name);
+            case SyntaxKind::ConstructorType:
+                return resolveNameToNode(node->to<ConstructorTypeNode>().name);
+            case SyntaxKind::PropertyAccessExpression:
+                return resolveNameToNode(node->to<PropertyAccessExpression>().name);
+            case SyntaxKind::MetaProperty:
+                return resolveNameToNode(node->to<MetaProperty>().name);
+            case SyntaxKind::ShorthandPropertyAssignment:
+                return resolveNameToNode(node->to<ShorthandPropertyAssignment>().name);
+            case SyntaxKind::Parameter:
+                return resolveNameToNode(node->to<ParameterDeclaration>().name);
+            case SyntaxKind::MissingDeclaration:
+                return resolveNameToNode(node->to<MissingDeclaration>().name);
+            case SyntaxKind::InterfaceDeclaration:
+                return resolveNameToNode(node->to<InterfaceDeclaration>().name);
+            case SyntaxKind::ClassDeclaration:
+                return resolveNameToNode(node->to<ClassDeclaration>().name);
+            case SyntaxKind::ClassExpression:
+                return resolveNameToNode(node->to<ClassExpression>().name);
+            case SyntaxKind::TypeAliasDeclaration:
+                return resolveNameToNode(node->to<TypeAliasDeclaration>().name);
+            case SyntaxKind::EnumDeclaration:
+                return resolveNameToNode(node->to<EnumDeclaration>().name);
+            case SyntaxKind::EnumMember:
+                return resolveNameToNode(node->to<EnumMember>().name);
+            case SyntaxKind::PropertySignature:
+                return resolveNameToNode(node->to<PropertySignature>().name);
+            case SyntaxKind::ModuleDeclaration:
+                return resolveNameToNode(node->to<ModuleDeclaration>().name);
+            case SyntaxKind::ImportEqualsDeclaration:
+                return resolveNameToNode(node->to<ImportEqualsDeclaration>().name);
+            case SyntaxKind::NamespaceImport:
+                return resolveNameToNode(node->to<NamespaceImport>().name);
+            case SyntaxKind::ImportSpecifier:
+                return resolveNameToNode(node->to<ImportSpecifier>().name);
+            case SyntaxKind::AssertEntry:
+                return resolveNameToNode(node->to<AssertEntry>().name);
+            case SyntaxKind::ImportClause:
+                return resolveNameToNode(node->to<ImportClause>().name);
+            case SyntaxKind::NamespaceExport:
+                return resolveNameToNode(node->to<NamespaceExport>().name);
+            case SyntaxKind::ExportSpecifier:
+                return resolveNameToNode(node->to<ExportSpecifier>().name);
+            case SyntaxKind::ExportDeclaration:
+                return resolveNameToNode(node->to<ExportDeclaration>().name);
+            case SyntaxKind::NamespaceExportDeclaration:
+                return resolveNameToNode(node->to<NamespaceExportDeclaration>().name);
+            case SyntaxKind::MethodSignature:
+                return resolveNameToNode(node->to<MethodSignature>().name);
+            case SyntaxKind::FunctionDeclaration:
+                return resolveNameToNode(node->to<FunctionDeclaration>().name);
+            case SyntaxKind::MethodDeclaration:
+                return resolveNameToNode(node->to<MethodDeclaration>().name);
+            case SyntaxKind::GetAccessor:
+                return resolveNameToNode(node->to<GetAccessorDeclaration>().name);
+            case SyntaxKind::SetAccessor:
+                return resolveNameToNode(node->to<SetAccessorDeclaration>().name);
+            case SyntaxKind::FunctionExpression:
+                return resolveNameToNode(node->to<FunctionExpression>().name);
+            case SyntaxKind::NamedTupleMember:
+                return resolveNameToNode(node->to<NamedTupleMember>().name);
+            case SyntaxKind::JsxAttribute:
+                return resolveNameToNode(node->to<JsxAttribute>().name);
+            case SyntaxKind::TypeParameter:
+                return resolveNameToNode(node->to<TypeParameterDeclaration>().name);
+            case SyntaxKind::BindingElement:
+                return resolveNameToNode(node->to<BindingElement>().name);
+            case SyntaxKind::VariableDeclaration:
+                return resolveNameToNode(node->to<VariableDeclaration>().name);
+            case SyntaxKind::IndexSignature:
+                return resolveNameToNode(node->to<IndexSignatureDeclaration>().name);
+            case SyntaxKind::CallSignature:
+                return resolveNameToNode(node->to<CallSignatureDeclaration>().name);
+            case SyntaxKind::ConstructSignature:
+                return resolveNameToNode(node->to<ConstructSignatureDeclaration>().name);
+            case SyntaxKind::ExportAssignment:
+                return resolveNameToNode(node->to<ExportAssignment>().name);
+            default:
+                if (auto v = dynamic_pointer_cast<PropertyAccessEntityNameExpression>(node)) {
+                    return resolveNameToNode(v->name);
+                }
+        }
 
         return nullptr;
     }
diff --git a/src/node_test.h b/src/node_test.h
index 6609624..6fe4cf3 100644
--- a/src/node_test.h
+++ b/src/node_test.h
@@ -25,7 +25,7 @@ namespace ts {
 
     ModifierFlags modifierToFlag(SyntaxKind token);
 
-    int modifiersToFlags(optional<NodeArray> modifiers);
+    int modifiersToFlags(sharedOpt<NodeArray> modifiers);
 
     /**
      * Gets the ModifierFlags for syntactic modifiers on the provided node. The modifier flags cache on the node is ignored.
@@ -48,7 +48,7 @@ namespace ts {
 
     bool isFunctionOrConstructorTypeNode(shared<Node> node);
 
-    optional<NodeArray> getTypeParameters(shared<Node> node);
+    sharedOpt<NodeArray> getTypeParameters(shared<Node> node);
 
     shared<NodeUnion(JsxTagNameExpression)> getTagName(shared<NodeUnion(JsxOpeningElement, JsxOpeningFragment)> node);
 
diff --git a/src/parenthesizer.cpp b/src/parenthesizer.cpp
index 858113f..a23c386 100644
--- a/src/parenthesizer.cpp
+++ b/src/parenthesizer.cpp
@@ -8,12 +8,12 @@
 namespace ts {
 
     template<typename T>
-    NodeArray sameMap(optional<NodeArray> array, function<shared<T>(shared<T>, int)> callback) {
-        NodeArray result;
+    shared<NodeArray> sameMap(const sharedOpt<NodeArray> &array, const function<shared<T>(shared<T>, int)> &callback) {
+        auto result = make_shared<NodeArray>();
         if (array) {
             auto i = 0;
             for (auto &v: array->list) {
-                result.list.push_back(callback(dynamic_pointer_cast<T>(v), i++));
+                result->list.push_back(callback(reinterpret_pointer_cast<T>(v), i++));
             }
         }
         return result;
@@ -33,7 +33,7 @@ namespace ts {
         return condition;
     }
 
-    optional<NodeArray> Parenthesizer::parenthesizeTypeArguments(optional<NodeArray> typeArguments) {
+    sharedOpt<NodeArray> Parenthesizer::parenthesizeTypeArguments(sharedOpt<NodeArray> typeArguments) {
         if (typeArguments && (*typeArguments).empty()) {
             auto m = sameMap<TypeNode>(typeArguments, CALLBACK(parenthesizeOrdinalTypeArgument));
             return factory->createNodeArray(m);
@@ -50,7 +50,7 @@ namespace ts {
                : branch;
     }
     
-    NodeArray Parenthesizer::parenthesizeElementTypesOfTupleType(NodeArray types) {
+    shared<NodeArray> Parenthesizer::parenthesizeElementTypesOfTupleType(shared<NodeArray> types) {
         return factory->createNodeArray(sameMap<TypeNode>(types, CALLBACK(parenthesizeElementTypeOfTupleType)));
     }
     
@@ -58,7 +58,7 @@ namespace ts {
         return isFunctionOrConstructorTypeNode(node) && getTypeParameters(node) ? factory->createParenthesizedType(node) : node;
     }
 
-    NodeArray Parenthesizer::parenthesizeConstituentTypesOfIntersectionType(NodeArray members) {
+    shared<NodeArray> Parenthesizer::parenthesizeConstituentTypesOfIntersectionType(shared<NodeArray> members) {
         return factory->createNodeArray(sameMap<TypeNode>(members, CALLBACK(parenthesizeConstituentTypeOfIntersectionType)));
     }
 
@@ -110,7 +110,7 @@ namespace ts {
         if (isLeftHandSideExpression(emittedExpression)
             && (emittedExpression->kind != SyntaxKind::NewExpression || emittedExpression->to<NewExpression>().arguments)) {
             // TODO(rbuckton): Verify whether this assertion holds.
-            return dynamic_pointer_cast<LeftHandSideExpression>(expression);
+            return reinterpret_pointer_cast<LeftHandSideExpression>(expression);
         }
 
         // TODO(rbuckton): Verifiy whether `setTextRange` is needed.
@@ -130,7 +130,7 @@ namespace ts {
             case SyntaxKind::NewExpression:
                 return !leftmostExpr->to<NewExpression>().arguments
                        ? factory->createParenthesizedExpression(expression)
-                       : dynamic_pointer_cast<LeftHandSideExpression>(expression); // TODO(rbuckton): Verify this assertion holds
+                       : reinterpret_pointer_cast<LeftHandSideExpression>(expression); // TODO(rbuckton): Verify this assertion holds
         }
 
         return parenthesizeLeftSideOfAccess(expression);
@@ -138,12 +138,12 @@ namespace ts {
 
     shared<LeftHandSideExpression> Parenthesizer::parenthesizeOperandOfPostfixUnary(shared<Expression> operand) {
         // TODO(rbuckton): Verifiy whether `setTextRange` is needed.
-        return isLeftHandSideExpression(operand) ? dynamic_pointer_cast<LeftHandSideExpression>(operand) : setTextRange(factory->createParenthesizedExpression(operand), operand);
+        return isLeftHandSideExpression(operand) ? reinterpret_pointer_cast<LeftHandSideExpression>(operand) : setTextRange(factory->createParenthesizedExpression(operand), operand);
     }
 
     shared<UnaryExpression> Parenthesizer::parenthesizeOperandOfPrefixUnary(shared<Expression> operand) {
         // TODO(rbuckton): Verifiy whether `setTextRange` is needed.
-        return isUnaryExpression(operand) ? dynamic_pointer_cast<UnaryExpression>(operand) : setTextRange(factory->createParenthesizedExpression(operand), operand);
+        return isUnaryExpression(operand) ? reinterpret_pointer_cast<UnaryExpression>(operand) : setTextRange(factory->createParenthesizedExpression(operand), operand);
     }
 
     shared<Expression> Parenthesizer::parenthesizeExpressionForDisallowedComma(shared<Expression> expression, int) {
@@ -154,9 +154,9 @@ namespace ts {
         return expressionPrecedence > commaPrecedence ? expression : setTextRange(factory->createParenthesizedExpression(expression), expression);
     }
 
-    NodeArray Parenthesizer::parenthesizeExpressionsOfCommaDelimitedList(NodeArray elements) {
+    shared<NodeArray> Parenthesizer::parenthesizeExpressionsOfCommaDelimitedList(shared<NodeArray> elements) {
         auto result = sameMap<Expression>(elements, CALLBACK(parenthesizeExpressionForDisallowedComma));
-        return setTextRange(factory->createNodeArray(result, elements.hasTrailingComma), elements);
+        return setTextRange(factory->createNodeArray(result, elements->hasTrailingComma), elements);
     }
 
     shared<Expression> Parenthesizer::parenthesizeExpressionOfExpressionStatement(shared<Expression> expression) {
@@ -189,7 +189,7 @@ namespace ts {
 //    function parenthesizeConciseBodyOfArrowFunction(body: ConciseBody): ConciseBody;
     shared<Node> Parenthesizer::parenthesizeConciseBodyOfArrowFunction(shared<Node> body) {
         if (isBlock(body)) return body;
-        auto e = dynamic_pointer_cast<Expression>(body);
+        auto e = reinterpret_pointer_cast<Expression>(body);
         if (isCommaSequence(body) || getLeftmostExpression(e, /*stopAtCallExpressions*/ false)->kind == SyntaxKind::ObjectLiteralExpression) {
             // TODO(rbuckton): Verifiy whether `setTextRange` is needed.
             return setTextRange(factory->createParenthesizedExpression(e), body);
@@ -241,7 +241,7 @@ namespace ts {
         return parenthesizeCheckTypeOfConditionalType(type);
     }
 
-    NodeArray Parenthesizer::parenthesizeConstituentTypesOfUnionType(NodeArray members) {
+    shared<NodeArray> Parenthesizer::parenthesizeConstituentTypesOfUnionType(shared<NodeArray> members) {
         return factory->createNodeArray(sameMap<TypeNode>(members, CALLBACK(parenthesizeConstituentTypeOfUnionType)));
     }
 }
diff --git a/src/parenthesizer.h b/src/parenthesizer.h
index 9ea0005..33514b0 100644
--- a/src/parenthesizer.h
+++ b/src/parenthesizer.h
@@ -270,7 +270,7 @@ namespace ts {
 
         shared <Expression> parenthesizeExpressionForDisallowedComma(shared <Expression> expression, int = 0);
 
-        NodeArray parenthesizeExpressionsOfCommaDelimitedList(NodeArray elements);
+        shared<NodeArray> parenthesizeExpressionsOfCommaDelimitedList(shared<NodeArray> elements);
 
         shared <Expression> parenthesizeExpressionOfExpressionStatement(shared <Expression> expression);
 
@@ -300,7 +300,7 @@ namespace ts {
         // - A union type constituent has the same precedence as the check type of a conditional type
         shared <TypeNode> parenthesizeConstituentTypeOfUnionType(shared <TypeNode> type, int = 0);
 
-        NodeArray parenthesizeConstituentTypesOfUnionType(NodeArray members);
+        shared <NodeArray> parenthesizeConstituentTypesOfUnionType(shared <NodeArray> members);
 
         // IntersectionType[Extends] :
         //     `&`? TypeOperator[?Extends]
@@ -309,7 +309,7 @@ namespace ts {
         // - An intersection type constituent does not allow function, constructor, conditional, or union types (they must be parenthesized)
         shared <TypeNode> parenthesizeConstituentTypeOfIntersectionType(shared <TypeNode> type, int = 0);
 
-        NodeArray parenthesizeConstituentTypesOfIntersectionType(NodeArray members);
+        shared<NodeArray> parenthesizeConstituentTypesOfIntersectionType(shared<NodeArray> members);
 
         // TypeOperator[Extends] :
         //     PostfixType
@@ -372,7 +372,7 @@ namespace ts {
         // RestType :
         //     `...` Type[~Extends]
         //
-        NodeArray parenthesizeElementTypesOfTupleType(NodeArray types);
+        shared <NodeArray> parenthesizeElementTypesOfTupleType(shared <NodeArray> types);
 
 //    function hasJSDocPostfixQuestion(shared<TypeNode> type | NamedTupleMember): boolean {
 //        if (isJSDocNullableType(type)) return type.postfix;
@@ -417,6 +417,6 @@ namespace ts {
             return i == 0 ? parenthesizeLeadingTypeArgument(node) : node;
         }
 
-        optional<NodeArray> parenthesizeTypeArguments(optional<NodeArray> typeArguments);
+        sharedOpt<NodeArray> parenthesizeTypeArguments(sharedOpt<NodeArray> typeArguments);
     };
 }
diff --git a/src/parser2.cpp b/src/parser2.cpp
index 16adbc7..c19132f 100644
--- a/src/parser2.cpp
+++ b/src/parser2.cpp
@@ -11,16 +11,20 @@ namespace ts {
     }
 
     optional<DiagnosticWithDetachedLocation> Parser::parseErrorAtPosition(int start, int length, const DiagnosticMessage &message, DiagnosticArg arg) {
-        // Mark that we've encountered an error.  We'll set an appropriate bit on the next
-        // node we finish so that it can't be reused incrementally.
-        parseErrorBeforeNextFinishedNode = true;
+        ZoneScoped;
 
+        auto lastError = lastOrUndefined(parseDiagnostics);
         // Don't report another error if it would just be at the same position as the last error.
-        if (!parseDiagnostics.empty() || start != parseDiagnostics.back().start) {
+        if (!lastError || start != lastError->start) {
             auto d = createDetachedDiagnostic(fileName, start, length, message, {arg});
             parseDiagnostics.push_back(d);
             return d;
         }
+
+        // Mark that we've encountered an error.  We'll set an appropriate bit on the next
+        // node we finish so that it can't be reused incrementally.
+        parseErrorBeforeNextFinishedNode = true;
+
         return nullopt;
     }
 
diff --git a/src/parser2.h b/src/parser2.h
index 708aee9..fa5bd0d 100644
--- a/src/parser2.h
+++ b/src/parser2.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Tracy.hpp"
 #include <functional>
 #include <variant>
 #include <optional>
@@ -97,7 +98,7 @@ namespace ts {
 ////    /* @internal */
 ////    export const parseNodeFactory = createNodeFactory(NodeFactoryFlags.NoParenthesizerRules, parseBaseNodeFactory);
 
-    sharedOpt<Node> visitNode(function<sharedOpt<Node>(shared<Node>)> cbNode, sharedOpt<Node> node) {
+    inline sharedOpt<Node> visitNode(const function<sharedOpt<Node>(shared<Node>)> &cbNode, const sharedOpt<Node> &node) {
         if (node) cbNode(node);
         return nullptr;
     }
@@ -106,14 +107,20 @@ namespace ts {
 //        return cbNode(node);
 //    }
 
-    sharedOpt<Node> visitNodes(
-            function<sharedOpt<Node>(shared<Node>)> cbNode,
-            optional<function<sharedOpt<Node>(NodeArray)>> cbNodes,
-            optional<NodeArray> nodes
+    inline sharedOpt<Node> noop(const shared<NodeArray> &) {
+        return nullptr;
+    };
+
+    inline sharedOpt<Node> forEachChild(const shared<Node> &node, const function<sharedOpt<Node>(shared<Node>)> &cbNode, const function<sharedOpt<Node>(shared<NodeArray>)> &cbNodes = noop);
+
+    inline sharedOpt<Node> visitNodes(
+            const function<sharedOpt<Node>(shared<Node>)> &cbNode,
+            const function<sharedOpt<Node>(shared<NodeArray>)> &cbNodes = noop,
+            const sharedOpt<NodeArray> &nodes = nullptr
     ) {
         if (nodes) {
             if (cbNodes) {
-                return (*cbNodes)(*nodes);
+                return cbNodes(nodes);
             }
             for (auto node: nodes->list) {
                 auto result = cbNode(node);
@@ -130,10 +137,10 @@ namespace ts {
      * returns a truthy value, then returns that value.
      * If no such value is found, the callback is applied to each element of array and undefined is returned.
      */
-    sharedOpt<Node> forEach(optional<NodeArray> array, function<sharedOpt<Node>(shared<Node> element, int index)> callback) {
+    inline sharedOpt<Node> forEach(const sharedOpt<NodeArray> &array, const function<sharedOpt<Node>(shared<Node> element, int index)> &callback) {
         if (array) {
             for (int i = 0; i < array->list.size(); i++) {
-                auto result = callback((*array).list[i], i);
+                auto result = callback(array->list[i], i);
                 if (result) {
                     return result;
                 }
@@ -147,7 +154,7 @@ namespace ts {
 //     * returns a truthy value, then returns that value.
 //     * If no such value is found, the callback is applied to each element of array and undefined is returned.
 //     */
-//    bool forEach(optional<NodeArray> array, function<bool(shared<Node> element, int index)> callback) {
+//    bool forEach(sharedOpt<NodeArray>  array, function<bool(shared<Node> element, int index)> callback) {
 //        if (array) {
 //            for (int i = 0; i < array->list.size(); i ++) {
 //                auto result = callback((*array).list[i], i);
@@ -159,29 +166,30 @@ namespace ts {
 //        return false;
 //    }
 
-    bool some(optional<NodeArray> array, optional<function<bool(shared<Node> value)>> predicate) {
+//    inline bool some(const sharedOpt<NodeArray> &array) {
+//        if (array) {
+//            return array->list.size() > 0;
+//        }
+//        return false;
+//    }
+
+    inline bool some(const sharedOpt<NodeArray> &array, const function<bool(shared<Node> value)> &predicate) {
         if (array) {
-            if (predicate) {
-                for (auto &v: array->list) {
-                    if ((*predicate)(v)) {
-                        return true;
-                    }
+            for (auto &v: array->list) {
+                if (predicate(v)) {
+                    return true;
                 }
-            } else {
-                return array->list.size() > 0;
             }
         }
         return false;
     }
 
-    sharedOpt<Node> forEachChild(const shared<Node> &node, function<sharedOpt<Node>(shared<Node>)> cbNode, optional<function<sharedOpt<Node>(NodeArray)>> cbNodes = nullopt);
-
     /** Do not use hasModifier inside the parser; it relies on parent pointers. Use this instead. */
-    bool hasModifierOfKind(const shared<Node> &node, SyntaxKind kind) {
-        return some(node->modifiers, [kind](auto m) { return m->kind == kind; });
+    inline bool hasModifierOfKind(const shared<Node> &node, SyntaxKind kind) {
+        return some<Node>(node->modifiers, [kind](auto m) { return m->kind == kind; });
     }
 
-    sharedOpt<Node> isAnExternalModuleIndicatorNode(shared<Node> node, int) {
+    inline sharedOpt<Node> isAnExternalModuleIndicatorNode(shared<Node> node, int) {
         if (hasModifierOfKind(node, SyntaxKind::ExportKeyword)
             || (node->is<ImportEqualsDeclaration>() && isExternalModuleReference(node->to<ImportEqualsDeclaration>().moduleReference))
             || isImportDeclaration(node)
@@ -191,7 +199,7 @@ namespace ts {
         return nullptr;
     }
 
-    bool isImportMeta(const shared<Node> &node) {
+    inline bool isImportMeta(const shared<Node> &node) {
         if (isMetaProperty(node)) {
             auto meta = node->to<MetaProperty>();
             return meta.keywordToken == SyntaxKind::ImportKeyword && meta.name->to<Identifier>().escapedText == "meta";
@@ -199,19 +207,19 @@ namespace ts {
         return false;
     }
 
-    sharedOpt<Node> walkTreeForImportMeta(const shared<Node> &node) {
+    inline sharedOpt<Node> walkTreeForImportMeta(const shared<Node> &node) {
         if (isImportMeta(node)) return node;
-        return forEachChild(node, walkTreeForImportMeta, nullopt);
+        return forEachChild(node, walkTreeForImportMeta);
     }
 
-    sharedOpt<Node> getImportMetaIfNecessary(const shared<SourceFile> &sourceFile) {
+    inline sharedOpt<Node> getImportMetaIfNecessary(const shared<SourceFile> &sourceFile) {
         return sourceFile->flags & (int) NodeFlags::PossiblyContainsImportMeta ?
                walkTreeForImportMeta(sourceFile) :
                nullptr;
     }
 
     /*@internal*/
-    sharedOpt<Node> isFileProbablyExternalModule(const shared<SourceFile> &sourceFile) {
+    inline sharedOpt<Node> isFileProbablyExternalModule(const shared<SourceFile> &sourceFile) {
         // Try to use the first top-level import/export when available, then
         // fall back to looking for an 'import.meta' somewhere in the tree if necessary.
         auto r = forEach(sourceFile->statements, isAnExternalModuleIndicatorNode);
@@ -219,7 +227,6 @@ namespace ts {
 
         return getImportMetaIfNecessary(sourceFile);
     }
-
     /**
      * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
      * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
@@ -233,85 +240,85 @@ namespace ts {
      * @remarks `forEachChild` must visit the children of a node in the order
      * that they appear in the source code. The language service depends on this property to locate nodes by position.
      */
-    sharedOpt<Node> forEachChild(Node &node, function<sharedOpt<Node>(shared<Node>)> cbNode, optional<function<sharedOpt<Node>(NodeArray)>> cbNodes) {
-        if (node.kind <= SyntaxKind::LastToken) {
+    inline sharedOpt<Node> forEachChild(const shared<Node> &node, const function<sharedOpt<Node>(shared<Node>)> &cbNode, const function<sharedOpt<Node>(shared<NodeArray>)> &cbNodes) {
+        if (node->kind <= SyntaxKind::LastToken) {
             return nullptr;
         }
-        switch (node.kind) {
+        switch (node->kind) {
             case SyntaxKind::QualifiedName:
                 //short-circuit evaluation is always boolean ... not last value in c++
-                return visitNode(cbNode, node.to<QualifiedName>().left) ||
-                       visitNode(cbNode, node.to<QualifiedName>().right);
+                return visitNode(cbNode, node->to<QualifiedName>().left) ||
+                       visitNode(cbNode, node->to<QualifiedName>().right);
             case SyntaxKind::TypeParameter:
-                return visitNodes(cbNode, cbNodes, node.to<TypeParameterDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<TypeParameterDeclaration>().name) ||
-                       visitNode(cbNode, node.to<TypeParameterDeclaration>().constraint) ||
-                       visitNode(cbNode, node.to<TypeParameterDeclaration>().defaultType) ||
-                       visitNode(cbNode, node.to<TypeParameterDeclaration>().expression);
+                return visitNodes(cbNode, cbNodes, node->to<TypeParameterDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<TypeParameterDeclaration>().name) ||
+                       visitNode(cbNode, node->to<TypeParameterDeclaration>().constraint) ||
+                       visitNode(cbNode, node->to<TypeParameterDeclaration>().defaultType) ||
+                       visitNode(cbNode, node->to<TypeParameterDeclaration>().expression);
             case SyntaxKind::ShorthandPropertyAssignment:
-                return visitNodes(cbNode, cbNodes, node.to<ShorthandPropertyAssignment>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ShorthandPropertyAssignment>().modifiers) ||
-                       visitNode(cbNode, node.to<ShorthandPropertyAssignment>().name) ||
-                       visitNode(cbNode, node.to<ShorthandPropertyAssignment>().questionToken) ||
-                       visitNode(cbNode, node.to<ShorthandPropertyAssignment>().exclamationToken) ||
-                       visitNode(cbNode, node.to<ShorthandPropertyAssignment>().equalsToken) ||
-                       visitNode(cbNode, node.to<ShorthandPropertyAssignment>().objectAssignmentInitializer);
+                return visitNodes(cbNode, cbNodes, node->to<ShorthandPropertyAssignment>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ShorthandPropertyAssignment>().modifiers) ||
+                       visitNode(cbNode, node->to<ShorthandPropertyAssignment>().name) ||
+                       visitNode(cbNode, node->to<ShorthandPropertyAssignment>().questionToken) ||
+                       visitNode(cbNode, node->to<ShorthandPropertyAssignment>().exclamationToken) ||
+                       visitNode(cbNode, node->to<ShorthandPropertyAssignment>().equalsToken) ||
+                       visitNode(cbNode, node->to<ShorthandPropertyAssignment>().objectAssignmentInitializer);
             case SyntaxKind::SpreadAssignment:
-                return visitNode(cbNode, node.to<SpreadAssignment>().expression);
+                return visitNode(cbNode, node->to<SpreadAssignment>().expression);
             case SyntaxKind::Parameter:
-                return visitNodes(cbNode, cbNodes, node.to<ParameterDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ParameterDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ParameterDeclaration>().dotDotDotToken) ||
-                       visitNode(cbNode, node.to<ParameterDeclaration>().name) ||
-                       visitNode(cbNode, node.to<ParameterDeclaration>().questionToken) ||
-                       visitNode(cbNode, node.to<ParameterDeclaration>().type) ||
-                       visitNode(cbNode, node.to<ParameterDeclaration>().initializer);
+                return visitNodes(cbNode, cbNodes, node->to<ParameterDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ParameterDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ParameterDeclaration>().dotDotDotToken) ||
+                       visitNode(cbNode, node->to<ParameterDeclaration>().name) ||
+                       visitNode(cbNode, node->to<ParameterDeclaration>().questionToken) ||
+                       visitNode(cbNode, node->to<ParameterDeclaration>().type) ||
+                       visitNode(cbNode, node->to<ParameterDeclaration>().initializer);
             case SyntaxKind::PropertyDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<PropertyDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<PropertyDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<PropertyDeclaration>().name) ||
-                       visitNode(cbNode, node.to<PropertyDeclaration>().questionToken) ||
-                       visitNode(cbNode, node.to<PropertyDeclaration>().exclamationToken) ||
-                       visitNode(cbNode, node.to<PropertyDeclaration>().type) ||
-                       visitNode(cbNode, node.to<PropertyDeclaration>().initializer);
+                return visitNodes(cbNode, cbNodes, node->to<PropertyDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<PropertyDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<PropertyDeclaration>().name) ||
+                       visitNode(cbNode, node->to<PropertyDeclaration>().questionToken) ||
+                       visitNode(cbNode, node->to<PropertyDeclaration>().exclamationToken) ||
+                       visitNode(cbNode, node->to<PropertyDeclaration>().type) ||
+                       visitNode(cbNode, node->to<PropertyDeclaration>().initializer);
             case SyntaxKind::PropertySignature:
-                return visitNodes(cbNode, cbNodes, node.to<PropertySignature>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<PropertySignature>().modifiers) ||
-                       visitNode(cbNode, node.to<PropertySignature>().name) ||
-                       visitNode(cbNode, node.to<PropertySignature>().questionToken) ||
-                       visitNode(cbNode, node.to<PropertySignature>().type) ||
-                       visitNode(cbNode, node.to<PropertySignature>().initializer);
+                return visitNodes(cbNode, cbNodes, node->to<PropertySignature>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<PropertySignature>().modifiers) ||
+                       visitNode(cbNode, node->to<PropertySignature>().name) ||
+                       visitNode(cbNode, node->to<PropertySignature>().questionToken) ||
+                       visitNode(cbNode, node->to<PropertySignature>().type) ||
+                       visitNode(cbNode, node->to<PropertySignature>().initializer);
             case SyntaxKind::PropertyAssignment:
-                return visitNodes(cbNode, cbNodes, node.to<PropertyAssignment>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<PropertyAssignment>().modifiers) ||
-                       visitNode(cbNode, node.to<PropertyAssignment>().name) ||
-                       visitNode(cbNode, node.to<PropertyAssignment>().questionToken) ||
-                       visitNode(cbNode, node.to<PropertyAssignment>().initializer);
+                return visitNodes(cbNode, cbNodes, node->to<PropertyAssignment>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<PropertyAssignment>().modifiers) ||
+                       visitNode(cbNode, node->to<PropertyAssignment>().name) ||
+                       visitNode(cbNode, node->to<PropertyAssignment>().questionToken) ||
+                       visitNode(cbNode, node->to<PropertyAssignment>().initializer);
             case SyntaxKind::VariableDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<VariableDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<VariableDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<VariableDeclaration>().name) ||
-                       visitNode(cbNode, node.to<VariableDeclaration>().exclamationToken) ||
-                       visitNode(cbNode, node.to<VariableDeclaration>().type) ||
-                       visitNode(cbNode, node.to<VariableDeclaration>().initializer);
+                return visitNodes(cbNode, cbNodes, node->to<VariableDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<VariableDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<VariableDeclaration>().name) ||
+                       visitNode(cbNode, node->to<VariableDeclaration>().exclamationToken) ||
+                       visitNode(cbNode, node->to<VariableDeclaration>().type) ||
+                       visitNode(cbNode, node->to<VariableDeclaration>().initializer);
             case SyntaxKind::BindingElement: {
-                return visitNodes(cbNode, cbNodes, node.to<BindingElement>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<BindingElement>().modifiers) ||
-                       visitNode(cbNode, node.to<BindingElement>().dotDotDotToken) ||
-                       visitNode(cbNode, node.to<BindingElement>().propertyName) ||
-                       visitNode(cbNode, node.to<BindingElement>().name) ||
-                       visitNode(cbNode, node.to<BindingElement>().initializer);
+                return visitNodes(cbNode, cbNodes, node->to<BindingElement>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<BindingElement>().modifiers) ||
+                       visitNode(cbNode, node->to<BindingElement>().dotDotDotToken) ||
+                       visitNode(cbNode, node->to<BindingElement>().propertyName) ||
+                       visitNode(cbNode, node->to<BindingElement>().name) ||
+                       visitNode(cbNode, node->to<BindingElement>().initializer);
             }
             case SyntaxKind::FunctionType:
             case SyntaxKind::ConstructorType:
             case SyntaxKind::CallSignature:
             case SyntaxKind::ConstructSignature:
             case SyntaxKind::IndexSignature:
-                return visitNodes(cbNode, cbNodes, node.decorators) ||
-                       visitNodes(cbNode, cbNodes, node.modifiers) ||
-                       visitNodes(cbNode, cbNodes, node.to<IndexSignatureDeclaration>().typeParameters) ||
-                       visitNodes(cbNode, cbNodes, node.to<IndexSignatureDeclaration>().parameters) ||
-                       visitNode(cbNode, node.to<IndexSignatureDeclaration>().type);
+                return visitNodes(cbNode, cbNodes, node->decorators) ||
+                       visitNodes(cbNode, cbNodes, node->modifiers) ||
+                       visitNodes(cbNode, cbNodes, node->to<IndexSignatureDeclaration>().typeParameters) ||
+                       visitNodes(cbNode, cbNodes, node->to<IndexSignatureDeclaration>().parameters) ||
+                       visitNode(cbNode, node->to<IndexSignatureDeclaration>().type);
             case SyntaxKind::MethodDeclaration:
             case SyntaxKind::MethodSignature:
             case SyntaxKind::Constructor:
@@ -320,358 +327,358 @@ namespace ts {
             case SyntaxKind::FunctionExpression:
             case SyntaxKind::FunctionDeclaration:
             case SyntaxKind::ArrowFunction: {
-                if (auto b = visitNodes(cbNode, cbNodes, node.decorators)) return b;
-
-                return visitNodes(cbNode, cbNodes, node.decorators) ||
-                       visitNodes(cbNode, cbNodes, node.modifiers) ||
-                       visitNode(cbNode, node.cast<FunctionLikeDeclarationBase>().asteriskToken) ||
-                       visitNode(cbNode, node.cast<FunctionLikeDeclarationBase>().name) ||
-                       visitNode(cbNode, node.cast<FunctionLikeDeclarationBase>().questionToken) ||
-                       visitNode(cbNode, node.cast<FunctionLikeDeclarationBase>().exclamationToken) ||
-                       visitNodes(cbNode, cbNodes, node.cast<FunctionLikeDeclarationBase>().typeParameters) ||
-                       visitNodes(cbNode, cbNodes, node.cast<FunctionLikeDeclarationBase>().parameters) ||
-                       visitNode(cbNode, node.cast<FunctionLikeDeclarationBase>().type) ||
-                       (node.kind == SyntaxKind::ArrowFunction ? visitNode(cbNode, node.to<ArrowFunction>().equalsGreaterThanToken) : shared<Node>(nullptr)) ||
-                       visitNode(cbNode, node.cast<FunctionLikeDeclarationBase>().body);
+                if (auto b = visitNodes(cbNode, cbNodes, node->decorators)) return b;
+
+                return visitNodes(cbNode, cbNodes, node->decorators) ||
+                       visitNodes(cbNode, cbNodes, node->modifiers) ||
+                       visitNode(cbNode, node->cast<FunctionLikeDeclarationBase>().asteriskToken) ||
+                       visitNode(cbNode, node->cast<FunctionLikeDeclarationBase>().name) ||
+                       visitNode(cbNode, node->cast<FunctionLikeDeclarationBase>().questionToken) ||
+                       visitNode(cbNode, node->cast<FunctionLikeDeclarationBase>().exclamationToken) ||
+                       visitNodes(cbNode, cbNodes, node->cast<FunctionLikeDeclarationBase>().typeParameters) ||
+                       visitNodes(cbNode, cbNodes, node->cast<FunctionLikeDeclarationBase>().parameters) ||
+                       visitNode(cbNode, node->cast<FunctionLikeDeclarationBase>().type) ||
+                       (node->kind == SyntaxKind::ArrowFunction ? visitNode(cbNode, node->to<ArrowFunction>().equalsGreaterThanToken) : shared<Node>(nullptr)) ||
+                       visitNode(cbNode, node->cast<FunctionLikeDeclarationBase>().body);
             }
             case SyntaxKind::ClassStaticBlockDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<ClassStaticBlockDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassStaticBlockDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ClassStaticBlockDeclaration>().body);
+                return visitNodes(cbNode, cbNodes, node->to<ClassStaticBlockDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassStaticBlockDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ClassStaticBlockDeclaration>().body);
             case SyntaxKind::TypeReference:
-                return visitNode(cbNode, node.to<TypeReferenceNode>().typeName) ||
-                       visitNodes(cbNode, cbNodes, node.to<TypeReferenceNode>().typeArguments);
+                return visitNode(cbNode, node->to<TypeReferenceNode>().typeName) ||
+                       visitNodes(cbNode, cbNodes, node->to<TypeReferenceNode>().typeArguments);
             case SyntaxKind::TypePredicate:
-                return visitNode(cbNode, node.to<TypePredicateNode>().assertsModifier) ||
-                       visitNode(cbNode, node.to<TypePredicateNode>().parameterName) ||
-                       visitNode(cbNode, node.to<TypePredicateNode>().type);
+                return visitNode(cbNode, node->to<TypePredicateNode>().assertsModifier) ||
+                       visitNode(cbNode, node->to<TypePredicateNode>().parameterName) ||
+                       visitNode(cbNode, node->to<TypePredicateNode>().type);
             case SyntaxKind::TypeQuery:
-                return visitNode(cbNode, node.to<TypeQueryNode>().exprName) ||
-                       visitNodes(cbNode, cbNodes, node.to<TypeQueryNode>().typeArguments);
+                return visitNode(cbNode, node->to<TypeQueryNode>().exprName) ||
+                       visitNodes(cbNode, cbNodes, node->to<TypeQueryNode>().typeArguments);
             case SyntaxKind::TypeLiteral:
-                return visitNodes(cbNode, cbNodes, node.to<TypeLiteralNode>().members);
+                return visitNodes(cbNode, cbNodes, node->to<TypeLiteralNode>().members);
             case SyntaxKind::ArrayType:
-                return visitNode(cbNode, node.to<ArrayTypeNode>().elementType);
+                return visitNode(cbNode, node->to<ArrayTypeNode>().elementType);
             case SyntaxKind::TupleType:
-                return visitNodes(cbNode, cbNodes, node.to<TupleTypeNode>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<TupleTypeNode>().elements);
             case SyntaxKind::UnionType:
-                return visitNodes(cbNode, cbNodes, node.to<UnionTypeNode>().types);
+                return visitNodes(cbNode, cbNodes, node->to<UnionTypeNode>().types);
             case SyntaxKind::IntersectionType:
-                return visitNodes(cbNode, cbNodes, node.to<IntersectionTypeNode>().types);
+                return visitNodes(cbNode, cbNodes, node->to<IntersectionTypeNode>().types);
             case SyntaxKind::ConditionalType:
-                return visitNode(cbNode, node.to<ConditionalTypeNode>().checkType) ||
-                       visitNode(cbNode, node.to<ConditionalTypeNode>().extendsType) ||
-                       visitNode(cbNode, node.to<ConditionalTypeNode>().trueType) ||
-                       visitNode(cbNode, node.to<ConditionalTypeNode>().falseType);
+                return visitNode(cbNode, node->to<ConditionalTypeNode>().checkType) ||
+                       visitNode(cbNode, node->to<ConditionalTypeNode>().extendsType) ||
+                       visitNode(cbNode, node->to<ConditionalTypeNode>().trueType) ||
+                       visitNode(cbNode, node->to<ConditionalTypeNode>().falseType);
             case SyntaxKind::InferType:
-                return visitNode(cbNode, node.to<InferTypeNode>().typeParameter);
+                return visitNode(cbNode, node->to<InferTypeNode>().typeParameter);
             case SyntaxKind::ImportType:
-                return visitNode(cbNode, node.to<ImportTypeNode>().argument) ||
-                       visitNode(cbNode, node.to<ImportTypeNode>().assertions) ||
-                       visitNode(cbNode, node.to<ImportTypeNode>().qualifier) ||
-                       visitNodes(cbNode, cbNodes, node.to<ImportTypeNode>().typeArguments);
+                return visitNode(cbNode, node->to<ImportTypeNode>().argument) ||
+                       visitNode(cbNode, node->to<ImportTypeNode>().assertions) ||
+                       visitNode(cbNode, node->to<ImportTypeNode>().qualifier) ||
+                       visitNodes(cbNode, cbNodes, node->to<ImportTypeNode>().typeArguments);
             case SyntaxKind::ImportTypeAssertionContainer:
-                return visitNode(cbNode, node.to<ImportTypeAssertionContainer>().assertClause);
+                return visitNode(cbNode, node->to<ImportTypeAssertionContainer>().assertClause);
             case SyntaxKind::ParenthesizedType:
-                return visitNode(cbNode, node.to<ParenthesizedTypeNode>().type);
+                return visitNode(cbNode, node->to<ParenthesizedTypeNode>().type);
             case SyntaxKind::TypeOperator:
-                return visitNode(cbNode, node.to<TypeOperatorNode>().type);
+                return visitNode(cbNode, node->to<TypeOperatorNode>().type);
             case SyntaxKind::IndexedAccessType:
-                return visitNode(cbNode, node.to<IndexedAccessTypeNode>().objectType) ||
-                       visitNode(cbNode, node.to<IndexedAccessTypeNode>().indexType);
+                return visitNode(cbNode, node->to<IndexedAccessTypeNode>().objectType) ||
+                       visitNode(cbNode, node->to<IndexedAccessTypeNode>().indexType);
             case SyntaxKind::MappedType:
-                return visitNode(cbNode, node.to<MappedTypeNode>().readonlyToken) ||
-                       visitNode(cbNode, node.to<MappedTypeNode>().typeParameter) ||
-                       visitNode(cbNode, node.to<MappedTypeNode>().nameType) ||
-                       visitNode(cbNode, node.to<MappedTypeNode>().questionToken) ||
-                       visitNode(cbNode, node.to<MappedTypeNode>().type) ||
-                       visitNodes(cbNode, cbNodes, node.to<MappedTypeNode>().members);
+                return visitNode(cbNode, node->to<MappedTypeNode>().readonlyToken) ||
+                       visitNode(cbNode, node->to<MappedTypeNode>().typeParameter) ||
+                       visitNode(cbNode, node->to<MappedTypeNode>().nameType) ||
+                       visitNode(cbNode, node->to<MappedTypeNode>().questionToken) ||
+                       visitNode(cbNode, node->to<MappedTypeNode>().type) ||
+                       visitNodes(cbNode, cbNodes, node->to<MappedTypeNode>().members);
             case SyntaxKind::LiteralType:
-                return visitNode(cbNode, node.to<LiteralTypeNode>().literal);
+                return visitNode(cbNode, node->to<LiteralTypeNode>().literal);
             case SyntaxKind::NamedTupleMember:
-                return visitNode(cbNode, node.to<NamedTupleMember>().dotDotDotToken) ||
-                       visitNode(cbNode, node.to<NamedTupleMember>().name) ||
-                       visitNode(cbNode, node.to<NamedTupleMember>().questionToken) ||
-                       visitNode(cbNode, node.to<NamedTupleMember>().type);
+                return visitNode(cbNode, node->to<NamedTupleMember>().dotDotDotToken) ||
+                       visitNode(cbNode, node->to<NamedTupleMember>().name) ||
+                       visitNode(cbNode, node->to<NamedTupleMember>().questionToken) ||
+                       visitNode(cbNode, node->to<NamedTupleMember>().type);
             case SyntaxKind::ObjectBindingPattern:
-                return visitNodes(cbNode, cbNodes, node.to<ObjectBindingPattern>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<ObjectBindingPattern>().elements);
             case SyntaxKind::ArrayBindingPattern:
-                return visitNodes(cbNode, cbNodes, node.to<ArrayBindingPattern>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<ArrayBindingPattern>().elements);
             case SyntaxKind::ArrayLiteralExpression:
-                return visitNodes(cbNode, cbNodes, node.to<ArrayLiteralExpression>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<ArrayLiteralExpression>().elements);
             case SyntaxKind::ObjectLiteralExpression:
-                return visitNodes(cbNode, cbNodes, node.to<ObjectLiteralExpression>().properties);
+                return visitNodes(cbNode, cbNodes, node->to<ObjectLiteralExpression>().properties);
             case SyntaxKind::PropertyAccessExpression:
-                return visitNode(cbNode, node.to<PropertyAccessExpression>().expression) ||
-                       visitNode(cbNode, node.to<PropertyAccessExpression>().questionDotToken) ||
-                       visitNode(cbNode, node.to<PropertyAccessExpression>().name);
+                return visitNode(cbNode, node->to<PropertyAccessExpression>().expression) ||
+                       visitNode(cbNode, node->to<PropertyAccessExpression>().questionDotToken) ||
+                       visitNode(cbNode, node->to<PropertyAccessExpression>().name);
             case SyntaxKind::ElementAccessExpression:
-                return visitNode(cbNode, node.to<ElementAccessExpression>().expression) ||
-                       visitNode(cbNode, node.to<ElementAccessExpression>().questionDotToken) ||
-                       visitNode(cbNode, node.to<ElementAccessExpression>().argumentExpression);
+                return visitNode(cbNode, node->to<ElementAccessExpression>().expression) ||
+                       visitNode(cbNode, node->to<ElementAccessExpression>().questionDotToken) ||
+                       visitNode(cbNode, node->to<ElementAccessExpression>().argumentExpression);
             case SyntaxKind::CallExpression:
             case SyntaxKind::NewExpression:
-                return visitNode(cbNode, node.to<CallExpression>().expression) ||
-                       visitNode(cbNode, node.to<CallExpression>().questionDotToken) ||
-                       visitNodes(cbNode, cbNodes, node.to<CallExpression>().typeArguments) ||
-                       visitNodes(cbNode, cbNodes, node.to<CallExpression>().arguments);
+                return visitNode(cbNode, node->to<CallExpression>().expression) ||
+                       visitNode(cbNode, node->to<CallExpression>().questionDotToken) ||
+                       visitNodes(cbNode, cbNodes, node->to<CallExpression>().typeArguments) ||
+                       visitNodes(cbNode, cbNodes, node->to<CallExpression>().arguments);
             case SyntaxKind::TaggedTemplateExpression:
-                return visitNode(cbNode, node.to<TaggedTemplateExpression>().tag) ||
-                       visitNode(cbNode, node.to<TaggedTemplateExpression>().questionDotToken) ||
-                       visitNodes(cbNode, cbNodes, node.to<TaggedTemplateExpression>().typeArguments) ||
-                       visitNode(cbNode, node.to<TaggedTemplateExpression>().templateLiteral);
+                return visitNode(cbNode, node->to<TaggedTemplateExpression>().tag) ||
+                       visitNode(cbNode, node->to<TaggedTemplateExpression>().questionDotToken) ||
+                       visitNodes(cbNode, cbNodes, node->to<TaggedTemplateExpression>().typeArguments) ||
+                       visitNode(cbNode, node->to<TaggedTemplateExpression>().templateLiteral);
             case SyntaxKind::TypeAssertionExpression:
-                return visitNode(cbNode, node.to<TypeAssertion>().type) ||
-                       visitNode(cbNode, node.to<TypeAssertion>().expression);
+                return visitNode(cbNode, node->to<TypeAssertion>().type) ||
+                       visitNode(cbNode, node->to<TypeAssertion>().expression);
             case SyntaxKind::ParenthesizedExpression:
-                return visitNode(cbNode, node.to<ParenthesizedExpression>().expression);
+                return visitNode(cbNode, node->to<ParenthesizedExpression>().expression);
             case SyntaxKind::DeleteExpression:
-                return visitNode(cbNode, node.to<DeleteExpression>().expression);
+                return visitNode(cbNode, node->to<DeleteExpression>().expression);
             case SyntaxKind::TypeOfExpression:
-                return visitNode(cbNode, node.to<TypeOfExpression>().expression);
+                return visitNode(cbNode, node->to<TypeOfExpression>().expression);
             case SyntaxKind::VoidExpression:
-                return visitNode(cbNode, node.to<VoidExpression>().expression);
+                return visitNode(cbNode, node->to<VoidExpression>().expression);
             case SyntaxKind::PrefixUnaryExpression:
-                return visitNode(cbNode, node.to<PrefixUnaryExpression>().operand);
+                return visitNode(cbNode, node->to<PrefixUnaryExpression>().operand);
             case SyntaxKind::YieldExpression:
-                return visitNode(cbNode, node.to<YieldExpression>().asteriskToken) ||
-                       visitNode(cbNode, node.to<YieldExpression>().expression);
+                return visitNode(cbNode, node->to<YieldExpression>().asteriskToken) ||
+                       visitNode(cbNode, node->to<YieldExpression>().expression);
             case SyntaxKind::AwaitExpression:
-                return visitNode(cbNode, node.to<AwaitExpression>().expression);
+                return visitNode(cbNode, node->to<AwaitExpression>().expression);
             case SyntaxKind::PostfixUnaryExpression:
-                return visitNode(cbNode, node.to<PostfixUnaryExpression>().operand);
+                return visitNode(cbNode, node->to<PostfixUnaryExpression>().operand);
             case SyntaxKind::BinaryExpression:
-                return visitNode(cbNode, node.to<BinaryExpression>().left) ||
-                       visitNode(cbNode, node.to<BinaryExpression>().operatorToken) ||
-                       visitNode(cbNode, node.to<BinaryExpression>().right);
+                return visitNode(cbNode, node->to<BinaryExpression>().left) ||
+                       visitNode(cbNode, node->to<BinaryExpression>().operatorToken) ||
+                       visitNode(cbNode, node->to<BinaryExpression>().right);
             case SyntaxKind::AsExpression:
-                return visitNode(cbNode, node.to<AsExpression>().expression) ||
-                       visitNode(cbNode, node.to<AsExpression>().type);
+                return visitNode(cbNode, node->to<AsExpression>().expression) ||
+                       visitNode(cbNode, node->to<AsExpression>().type);
             case SyntaxKind::NonNullExpression:
-                return visitNode(cbNode, node.to<NonNullExpression>().expression);
+                return visitNode(cbNode, node->to<NonNullExpression>().expression);
             case SyntaxKind::MetaProperty:
-                return visitNode(cbNode, node.to<MetaProperty>().name);
+                return visitNode(cbNode, node->to<MetaProperty>().name);
             case SyntaxKind::ConditionalExpression:
-                return visitNode(cbNode, node.to<ConditionalExpression>().condition) ||
-                       visitNode(cbNode, node.to<ConditionalExpression>().questionToken) ||
-                       visitNode(cbNode, node.to<ConditionalExpression>().whenTrue) ||
-                       visitNode(cbNode, node.to<ConditionalExpression>().colonToken) ||
-                       visitNode(cbNode, node.to<ConditionalExpression>().whenFalse);
+                return visitNode(cbNode, node->to<ConditionalExpression>().condition) ||
+                       visitNode(cbNode, node->to<ConditionalExpression>().questionToken) ||
+                       visitNode(cbNode, node->to<ConditionalExpression>().whenTrue) ||
+                       visitNode(cbNode, node->to<ConditionalExpression>().colonToken) ||
+                       visitNode(cbNode, node->to<ConditionalExpression>().whenFalse);
             case SyntaxKind::SpreadElement:
-                return visitNode(cbNode, node.to<SpreadElement>().expression);
+                return visitNode(cbNode, node->to<SpreadElement>().expression);
             case SyntaxKind::Block:
             case SyntaxKind::ModuleBlock:
-                return visitNodes(cbNode, cbNodes, node.to<Block>().statements);
+                return visitNodes(cbNode, cbNodes, node->to<Block>().statements);
             case SyntaxKind::SourceFile:
-                return visitNodes(cbNode, cbNodes, node.to<SourceFile>().statements) ||
-                       visitNode(cbNode, node.to<SourceFile>().endOfFileToken);
+                return visitNodes(cbNode, cbNodes, node->to<SourceFile>().statements) ||
+                       visitNode(cbNode, node->to<SourceFile>().endOfFileToken);
             case SyntaxKind::VariableStatement:
-                return visitNodes(cbNode, cbNodes, node.to<VariableStatement>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<VariableStatement>().modifiers) ||
-                       visitNode(cbNode, node.to<VariableStatement>().declarationList);
+                return visitNodes(cbNode, cbNodes, node->to<VariableStatement>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<VariableStatement>().modifiers) ||
+                       visitNode(cbNode, node->to<VariableStatement>().declarationList);
             case SyntaxKind::VariableDeclarationList:
-                return visitNodes(cbNode, cbNodes, node.to<VariableDeclarationList>().declarations);
+                return visitNodes(cbNode, cbNodes, node->to<VariableDeclarationList>().declarations);
             case SyntaxKind::ExpressionStatement:
-                return visitNode(cbNode, node.to<ExpressionStatement>().expression);
+                return visitNode(cbNode, node->to<ExpressionStatement>().expression);
             case SyntaxKind::IfStatement:
-                return visitNode(cbNode, node.to<IfStatement>().expression) ||
-                       visitNode(cbNode, node.to<IfStatement>().thenStatement) ||
-                       visitNode(cbNode, node.to<IfStatement>().elseStatement);
+                return visitNode(cbNode, node->to<IfStatement>().expression) ||
+                       visitNode(cbNode, node->to<IfStatement>().thenStatement) ||
+                       visitNode(cbNode, node->to<IfStatement>().elseStatement);
             case SyntaxKind::DoStatement:
-                return visitNode(cbNode, node.to<DoStatement>().statement) ||
-                       visitNode(cbNode, node.to<DoStatement>().expression);
+                return visitNode(cbNode, node->to<DoStatement>().statement) ||
+                       visitNode(cbNode, node->to<DoStatement>().expression);
             case SyntaxKind::WhileStatement:
-                return visitNode(cbNode, node.to<WhileStatement>().expression) ||
-                       visitNode(cbNode, node.to<WhileStatement>().statement);
+                return visitNode(cbNode, node->to<WhileStatement>().expression) ||
+                       visitNode(cbNode, node->to<WhileStatement>().statement);
             case SyntaxKind::ForStatement:
-                return visitNode(cbNode, node.to<ForStatement>().initializer) ||
-                       visitNode(cbNode, node.to<ForStatement>().condition) ||
-                       visitNode(cbNode, node.to<ForStatement>().incrementor) ||
-                       visitNode(cbNode, node.to<ForStatement>().statement);
+                return visitNode(cbNode, node->to<ForStatement>().initializer) ||
+                       visitNode(cbNode, node->to<ForStatement>().condition) ||
+                       visitNode(cbNode, node->to<ForStatement>().incrementor) ||
+                       visitNode(cbNode, node->to<ForStatement>().statement);
             case SyntaxKind::ForInStatement:
-                return visitNode(cbNode, node.to<ForInStatement>().initializer) ||
-                       visitNode(cbNode, node.to<ForInStatement>().expression) ||
-                       visitNode(cbNode, node.to<ForInStatement>().statement);
+                return visitNode(cbNode, node->to<ForInStatement>().initializer) ||
+                       visitNode(cbNode, node->to<ForInStatement>().expression) ||
+                       visitNode(cbNode, node->to<ForInStatement>().statement);
             case SyntaxKind::ForOfStatement:
-                return visitNode(cbNode, node.to<ForOfStatement>().awaitModifier) ||
-                       visitNode(cbNode, node.to<ForOfStatement>().initializer) ||
-                       visitNode(cbNode, node.to<ForOfStatement>().expression) ||
-                       visitNode(cbNode, node.to<ForOfStatement>().statement);
+                return visitNode(cbNode, node->to<ForOfStatement>().awaitModifier) ||
+                       visitNode(cbNode, node->to<ForOfStatement>().initializer) ||
+                       visitNode(cbNode, node->to<ForOfStatement>().expression) ||
+                       visitNode(cbNode, node->to<ForOfStatement>().statement);
             case SyntaxKind::ContinueStatement:
-                return visitNode(cbNode, node.to<ContinueStatement>().label);
+                return visitNode(cbNode, node->to<ContinueStatement>().label);
             case SyntaxKind::BreakStatement:
-                return visitNode(cbNode, node.to<BreakStatement>().label);
+                return visitNode(cbNode, node->to<BreakStatement>().label);
             case SyntaxKind::ReturnStatement:
-                return visitNode(cbNode, node.to<ReturnStatement>().expression);
+                return visitNode(cbNode, node->to<ReturnStatement>().expression);
             case SyntaxKind::WithStatement:
-                return visitNode(cbNode, node.to<WithStatement>().expression) ||
-                       visitNode(cbNode, node.to<WithStatement>().statement);
+                return visitNode(cbNode, node->to<WithStatement>().expression) ||
+                       visitNode(cbNode, node->to<WithStatement>().statement);
             case SyntaxKind::SwitchStatement:
-                return visitNode(cbNode, node.to<SwitchStatement>().expression) ||
-                       visitNode(cbNode, node.to<SwitchStatement>().caseBlock);
+                return visitNode(cbNode, node->to<SwitchStatement>().expression) ||
+                       visitNode(cbNode, node->to<SwitchStatement>().caseBlock);
             case SyntaxKind::CaseBlock:
-                return visitNodes(cbNode, cbNodes, node.to<CaseBlock>().clauses);
+                return visitNodes(cbNode, cbNodes, node->to<CaseBlock>().clauses);
             case SyntaxKind::CaseClause:
-                return visitNode(cbNode, node.to<CaseClause>().expression) ||
-                       visitNodes(cbNode, cbNodes, node.to<CaseClause>().statements);
+                return visitNode(cbNode, node->to<CaseClause>().expression) ||
+                       visitNodes(cbNode, cbNodes, node->to<CaseClause>().statements);
             case SyntaxKind::DefaultClause:
-                return visitNodes(cbNode, cbNodes, node.to<DefaultClause>().statements);
+                return visitNodes(cbNode, cbNodes, node->to<DefaultClause>().statements);
             case SyntaxKind::LabeledStatement:
-                return visitNode(cbNode, node.to<LabeledStatement>().label) ||
-                       visitNode(cbNode, node.to<LabeledStatement>().statement);
+                return visitNode(cbNode, node->to<LabeledStatement>().label) ||
+                       visitNode(cbNode, node->to<LabeledStatement>().statement);
             case SyntaxKind::ThrowStatement:
-                return visitNode(cbNode, node.to<ThrowStatement>().expression);
+                return visitNode(cbNode, node->to<ThrowStatement>().expression);
             case SyntaxKind::TryStatement:
-                return visitNode(cbNode, node.to<TryStatement>().tryBlock) ||
-                       visitNode(cbNode, node.to<TryStatement>().catchClause) ||
-                       visitNode(cbNode, node.to<TryStatement>().finallyBlock);
+                return visitNode(cbNode, node->to<TryStatement>().tryBlock) ||
+                       visitNode(cbNode, node->to<TryStatement>().catchClause) ||
+                       visitNode(cbNode, node->to<TryStatement>().finallyBlock);
             case SyntaxKind::CatchClause:
-                return visitNode(cbNode, node.to<CatchClause>().variableDeclaration) ||
-                       visitNode(cbNode, node.to<CatchClause>().block);
+                return visitNode(cbNode, node->to<CatchClause>().variableDeclaration) ||
+                       visitNode(cbNode, node->to<CatchClause>().block);
             case SyntaxKind::Decorator:
-                return visitNode(cbNode, node.to<Decorator>().expression);
+                return visitNode(cbNode, node->to<Decorator>().expression);
             case SyntaxKind::ClassDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<ClassDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ClassDeclaration>().name) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassDeclaration>().typeParameters) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassDeclaration>().heritageClauses) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassDeclaration>().members);
+                return visitNodes(cbNode, cbNodes, node->to<ClassDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ClassDeclaration>().name) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassDeclaration>().typeParameters) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassDeclaration>().heritageClauses) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassDeclaration>().members);
             case SyntaxKind::ClassExpression:
-                return visitNodes(cbNode, cbNodes, node.to<ClassExpression>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassExpression>().modifiers) ||
-                       visitNode(cbNode, node.to<ClassExpression>().name) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassExpression>().typeParameters) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassExpression>().heritageClauses) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassExpression>().members);
+                return visitNodes(cbNode, cbNodes, node->to<ClassExpression>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassExpression>().modifiers) ||
+                       visitNode(cbNode, node->to<ClassExpression>().name) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassExpression>().typeParameters) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassExpression>().heritageClauses) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassExpression>().members);
             case SyntaxKind::InterfaceDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<InterfaceDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<InterfaceDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<InterfaceDeclaration>().name) ||
-                       visitNodes(cbNode, cbNodes, node.to<InterfaceDeclaration>().typeParameters) ||
-                       visitNodes(cbNode, cbNodes, node.to<ClassDeclaration>().heritageClauses) ||
-                       visitNodes(cbNode, cbNodes, node.to<InterfaceDeclaration>().members);
+                return visitNodes(cbNode, cbNodes, node->to<InterfaceDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<InterfaceDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<InterfaceDeclaration>().name) ||
+                       visitNodes(cbNode, cbNodes, node->to<InterfaceDeclaration>().typeParameters) ||
+                       visitNodes(cbNode, cbNodes, node->to<ClassDeclaration>().heritageClauses) ||
+                       visitNodes(cbNode, cbNodes, node->to<InterfaceDeclaration>().members);
             case SyntaxKind::TypeAliasDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<TypeAliasDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<TypeAliasDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<TypeAliasDeclaration>().name) ||
-                       visitNodes(cbNode, cbNodes, node.to<TypeAliasDeclaration>().typeParameters) ||
-                       visitNode(cbNode, node.to<TypeAliasDeclaration>().type);
+                return visitNodes(cbNode, cbNodes, node->to<TypeAliasDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<TypeAliasDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<TypeAliasDeclaration>().name) ||
+                       visitNodes(cbNode, cbNodes, node->to<TypeAliasDeclaration>().typeParameters) ||
+                       visitNode(cbNode, node->to<TypeAliasDeclaration>().type);
             case SyntaxKind::EnumDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<EnumDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<EnumDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<EnumDeclaration>().name) ||
-                       visitNodes(cbNode, cbNodes, node.to<EnumDeclaration>().members);
+                return visitNodes(cbNode, cbNodes, node->to<EnumDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<EnumDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<EnumDeclaration>().name) ||
+                       visitNodes(cbNode, cbNodes, node->to<EnumDeclaration>().members);
             case SyntaxKind::EnumMember:
-                return visitNode(cbNode, node.to<EnumMember>().name) ||
-                       visitNode(cbNode, node.to<EnumMember>().initializer);
+                return visitNode(cbNode, node->to<EnumMember>().name) ||
+                       visitNode(cbNode, node->to<EnumMember>().initializer);
             case SyntaxKind::ModuleDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<ModuleDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ModuleDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ModuleDeclaration>().name) ||
-                       visitNode(cbNode, node.to<ModuleDeclaration>().body);
+                return visitNodes(cbNode, cbNodes, node->to<ModuleDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ModuleDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ModuleDeclaration>().name) ||
+                       visitNode(cbNode, node->to<ModuleDeclaration>().body);
             case SyntaxKind::ImportEqualsDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<ImportEqualsDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ImportEqualsDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ImportEqualsDeclaration>().name) ||
-                       visitNode(cbNode, node.to<ImportEqualsDeclaration>().moduleReference);
+                return visitNodes(cbNode, cbNodes, node->to<ImportEqualsDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ImportEqualsDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ImportEqualsDeclaration>().name) ||
+                       visitNode(cbNode, node->to<ImportEqualsDeclaration>().moduleReference);
             case SyntaxKind::ImportDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<ImportDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ImportDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ImportDeclaration>().importClause) ||
-                       visitNode(cbNode, node.to<ImportDeclaration>().moduleSpecifier) ||
-                       visitNode(cbNode, node.to<ImportDeclaration>().assertClause);
+                return visitNodes(cbNode, cbNodes, node->to<ImportDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ImportDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ImportDeclaration>().importClause) ||
+                       visitNode(cbNode, node->to<ImportDeclaration>().moduleSpecifier) ||
+                       visitNode(cbNode, node->to<ImportDeclaration>().assertClause);
             case SyntaxKind::ImportClause:
-                return visitNode(cbNode, node.to<ImportClause>().name) ||
-                       visitNode(cbNode, node.to<ImportClause>().namedBindings);
+                return visitNode(cbNode, node->to<ImportClause>().name) ||
+                       visitNode(cbNode, node->to<ImportClause>().namedBindings);
             case SyntaxKind::AssertClause:
-                return visitNodes(cbNode, cbNodes, node.to<AssertClause>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<AssertClause>().elements);
             case SyntaxKind::AssertEntry:
-                return visitNode(cbNode, node.to<AssertEntry>().name) ||
-                       visitNode(cbNode, node.to<AssertEntry>().value);
+                return visitNode(cbNode, node->to<AssertEntry>().name) ||
+                       visitNode(cbNode, node->to<AssertEntry>().value);
             case SyntaxKind::NamespaceExportDeclaration:
-                return visitNode(cbNode, node.to<NamespaceExportDeclaration>().name);
+                return visitNode(cbNode, node->to<NamespaceExportDeclaration>().name);
             case SyntaxKind::NamespaceImport:
-                return visitNode(cbNode, node.to<NamespaceImport>().name);
+                return visitNode(cbNode, node->to<NamespaceImport>().name);
             case SyntaxKind::NamespaceExport:
-                return visitNode(cbNode, node.to<NamespaceExport>().name);
+                return visitNode(cbNode, node->to<NamespaceExport>().name);
             case SyntaxKind::NamedImports:
-                return visitNodes(cbNode, cbNodes, node.to<NamedImports>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<NamedImports>().elements);
             case SyntaxKind::NamedExports:
-                return visitNodes(cbNode, cbNodes, node.to<NamedExports>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<NamedExports>().elements);
             case SyntaxKind::ExportDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<ExportDeclaration>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ExportDeclaration>().modifiers) ||
-                       visitNode(cbNode, node.to<ExportDeclaration>().exportClause) ||
-                       visitNode(cbNode, node.to<ExportDeclaration>().moduleSpecifier) ||
-                       visitNode(cbNode, node.to<ExportDeclaration>().assertClause);
+                return visitNodes(cbNode, cbNodes, node->to<ExportDeclaration>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ExportDeclaration>().modifiers) ||
+                       visitNode(cbNode, node->to<ExportDeclaration>().exportClause) ||
+                       visitNode(cbNode, node->to<ExportDeclaration>().moduleSpecifier) ||
+                       visitNode(cbNode, node->to<ExportDeclaration>().assertClause);
             case SyntaxKind::ImportSpecifier:
-                return visitNode(cbNode, node.to<ImportSpecifier>().propertyName) ||
-                       visitNode(cbNode, node.to<ImportSpecifier>().name);
+                return visitNode(cbNode, node->to<ImportSpecifier>().propertyName) ||
+                       visitNode(cbNode, node->to<ImportSpecifier>().name);
             case SyntaxKind::ExportSpecifier:
-                return visitNode(cbNode, node.to<ExportSpecifier>().propertyName) ||
-                       visitNode(cbNode, node.to<ExportSpecifier>().name);
+                return visitNode(cbNode, node->to<ExportSpecifier>().propertyName) ||
+                       visitNode(cbNode, node->to<ExportSpecifier>().name);
             case SyntaxKind::ExportAssignment:
-                return visitNodes(cbNode, cbNodes, node.to<ExportAssignment>().decorators) ||
-                       visitNodes(cbNode, cbNodes, node.to<ExportAssignment>().modifiers) ||
-                       visitNode(cbNode, node.to<ExportAssignment>().expression);
+                return visitNodes(cbNode, cbNodes, node->to<ExportAssignment>().decorators) ||
+                       visitNodes(cbNode, cbNodes, node->to<ExportAssignment>().modifiers) ||
+                       visitNode(cbNode, node->to<ExportAssignment>().expression);
             case SyntaxKind::TemplateExpression:
-                return visitNode(cbNode, node.to<TemplateExpression>().head) || visitNodes(cbNode, cbNodes, node.to<TemplateExpression>().templateSpans);
+                return visitNode(cbNode, node->to<TemplateExpression>().head) || visitNodes(cbNode, cbNodes, node->to<TemplateExpression>().templateSpans);
             case SyntaxKind::TemplateSpan:
-                return visitNode(cbNode, node.to<TemplateSpan>().expression) || visitNode(cbNode, node.to<TemplateSpan>().literal);
+                return visitNode(cbNode, node->to<TemplateSpan>().expression) || visitNode(cbNode, node->to<TemplateSpan>().literal);
             case SyntaxKind::TemplateLiteralType:
-                return visitNode(cbNode, node.to<TemplateLiteralTypeNode>().head) || visitNodes(cbNode, cbNodes, node.to<TemplateLiteralTypeNode>().templateSpans);
+                return visitNode(cbNode, node->to<TemplateLiteralTypeNode>().head) || visitNodes(cbNode, cbNodes, node->to<TemplateLiteralTypeNode>().templateSpans);
             case SyntaxKind::TemplateLiteralTypeSpan:
-                return visitNode(cbNode, node.to<TemplateLiteralTypeSpan>().type) || visitNode(cbNode, node.to<TemplateLiteralTypeSpan>().literal);
+                return visitNode(cbNode, node->to<TemplateLiteralTypeSpan>().type) || visitNode(cbNode, node->to<TemplateLiteralTypeSpan>().literal);
             case SyntaxKind::ComputedPropertyName:
-                return visitNode(cbNode, node.to<ComputedPropertyName>().expression);
+                return visitNode(cbNode, node->to<ComputedPropertyName>().expression);
             case SyntaxKind::HeritageClause:
-                return visitNodes(cbNode, cbNodes, node.to<HeritageClause>().types);
+                return visitNodes(cbNode, cbNodes, node->to<HeritageClause>().types);
             case SyntaxKind::ExpressionWithTypeArguments:
-                return visitNode(cbNode, node.to<ExpressionWithTypeArguments>().expression) ||
-                       visitNodes(cbNode, cbNodes, node.to<ExpressionWithTypeArguments>().typeArguments);
+                return visitNode(cbNode, node->to<ExpressionWithTypeArguments>().expression) ||
+                       visitNodes(cbNode, cbNodes, node->to<ExpressionWithTypeArguments>().typeArguments);
             case SyntaxKind::ExternalModuleReference:
-                return visitNode(cbNode, node.to<ExternalModuleReference>().expression);
+                return visitNode(cbNode, node->to<ExternalModuleReference>().expression);
             case SyntaxKind::MissingDeclaration:
-                return visitNodes(cbNode, cbNodes, node.to<MissingDeclaration>().decorators);
+                return visitNodes(cbNode, cbNodes, node->to<MissingDeclaration>().decorators);
             case SyntaxKind::CommaListExpression:
-                return visitNodes(cbNode, cbNodes, node.to<CommaListExpression>().elements);
+                return visitNodes(cbNode, cbNodes, node->to<CommaListExpression>().elements);
 
             case SyntaxKind::JsxElement:
-                return visitNode(cbNode, node.to<JsxElement>().openingElement) ||
-                       visitNodes(cbNode, cbNodes, node.to<JsxElement>().children) ||
-                       visitNode(cbNode, node.to<JsxElement>().closingElement);
+                return visitNode(cbNode, node->to<JsxElement>().openingElement) ||
+                       visitNodes(cbNode, cbNodes, node->to<JsxElement>().children) ||
+                       visitNode(cbNode, node->to<JsxElement>().closingElement);
             case SyntaxKind::JsxFragment:
-                return visitNode(cbNode, node.to<JsxFragment>().openingFragment) ||
-                       visitNodes(cbNode, cbNodes, node.to<JsxFragment>().children) ||
-                       visitNode(cbNode, node.to<JsxFragment>().closingFragment);
+                return visitNode(cbNode, node->to<JsxFragment>().openingFragment) ||
+                       visitNodes(cbNode, cbNodes, node->to<JsxFragment>().children) ||
+                       visitNode(cbNode, node->to<JsxFragment>().closingFragment);
             case SyntaxKind::JsxSelfClosingElement:
-                return visitNode(cbNode, node.to<JsxSelfClosingElement>().tagName) ||
-                       visitNodes(cbNode, cbNodes, node.to<JsxSelfClosingElement>().typeArguments) ||
-                       visitNode(cbNode, node.to<JsxSelfClosingElement>().attributes);
+                return visitNode(cbNode, node->to<JsxSelfClosingElement>().tagName) ||
+                       visitNodes(cbNode, cbNodes, node->to<JsxSelfClosingElement>().typeArguments) ||
+                       visitNode(cbNode, node->to<JsxSelfClosingElement>().attributes);
             case SyntaxKind::JsxOpeningElement:
-                return visitNode(cbNode, node.to<JsxOpeningElement>().tagName) ||
-                       visitNodes(cbNode, cbNodes, node.to<JsxOpeningElement>().typeArguments) ||
-                       visitNode(cbNode, node.to<JsxOpeningElement>().attributes);
+                return visitNode(cbNode, node->to<JsxOpeningElement>().tagName) ||
+                       visitNodes(cbNode, cbNodes, node->to<JsxOpeningElement>().typeArguments) ||
+                       visitNode(cbNode, node->to<JsxOpeningElement>().attributes);
             case SyntaxKind::JsxAttributes:
-                return visitNodes(cbNode, cbNodes, node.to<JsxAttributes>().properties);
+                return visitNodes(cbNode, cbNodes, node->to<JsxAttributes>().properties);
             case SyntaxKind::JsxAttribute:
-                return visitNode(cbNode, node.to<JsxAttribute>().name) ||
-                       visitNode(cbNode, node.to<JsxAttribute>().initializer);
+                return visitNode(cbNode, node->to<JsxAttribute>().name) ||
+                       visitNode(cbNode, node->to<JsxAttribute>().initializer);
             case SyntaxKind::JsxSpreadAttribute:
-                return visitNode(cbNode, node.to<JsxSpreadAttribute>().expression);
+                return visitNode(cbNode, node->to<JsxSpreadAttribute>().expression);
             case SyntaxKind::JsxExpression:
-                return visitNode(cbNode, node.to<JsxExpression>().dotDotDotToken) ||
-                       visitNode(cbNode, node.to<JsxExpression>().expression);
+                return visitNode(cbNode, node->to<JsxExpression>().dotDotDotToken) ||
+                       visitNode(cbNode, node->to<JsxExpression>().expression);
             case SyntaxKind::JsxClosingElement:
-                return visitNode(cbNode, node.to<JsxClosingElement>().tagName);
+                return visitNode(cbNode, node->to<JsxClosingElement>().tagName);
 
             case SyntaxKind::OptionalType:
-                return visitNode(cbNode, node.to<OptionalTypeNode>().type);
+                return visitNode(cbNode, node->to<OptionalTypeNode>().type);
             case SyntaxKind::RestType:
-                return visitNode(cbNode, node.to<RestTypeNode>().type);
+                return visitNode(cbNode, node->to<RestTypeNode>().type);
             case SyntaxKind::PartiallyEmittedExpression:
-                return visitNode(cbNode, node.to<PartiallyEmittedExpression>().expression);
+                return visitNode(cbNode, node->to<PartiallyEmittedExpression>().expression);
         }
     }
 
@@ -764,7 +771,7 @@ namespace ts {
 //        sourceFile.externalModuleIndicator = isFileProbablyExternalModule(sourceFile);
 //    }
 
-    void setExternalModuleIndicator(shared<SourceFile> sourceFile) {
+    inline void setExternalModuleIndicator(const shared<SourceFile> &sourceFile) {
         sourceFile->externalModuleIndicator = isFileProbablyExternalModule(sourceFile);
     }
 
@@ -785,12 +792,12 @@ namespace ts {
 //    export function parseJsonText(fileName: string, sourceText: string): JsonSourceFile {
 //        return Parser.parseJsonText(fileName, sourceText);
 //    }
-//
-//    // See also `isExternalOrCommonJsModule` in utilities.ts
-//    export function isExternalModule(file: SourceFile): boolean {
-//        return file.externalModuleIndicator != undefined;
-//    }
-//
+
+    // See also `isExternalOrCommonJsModule` in utilities.ts
+    inline bool isExternalModule(const shared<SourceFile> &file) {
+        return (bool) file->externalModuleIndicator;
+    }
+
 //    // Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter
 //    // indicates what changed between the 'text' that this SourceFile has and the 'newText'.
 //    // The SourceFile will be created with the compiler attempting to reuse as many nodes from
@@ -835,7 +842,7 @@ namespace ts {
         Scanner scanner{ScriptTarget::Latest, /*skipTrivia*/ true};
         Factory factory;
 
-        int disallowInAndDecoratorContext = (int)NodeFlags::DisallowInContext | (int)NodeFlags::DecoratorContext;
+        int disallowInAndDecoratorContext = (int) NodeFlags::DisallowInContext | (int) NodeFlags::DecoratorContext;
 
 //        // capture constructors in 'initializeState' to avoid null checks
 //        // tslint:disable variable-name
@@ -987,6 +994,7 @@ namespace ts {
         }
 
         SyntaxKind nextToken() {
+            ZoneScoped;
             // if the keyword had an escape
             if (isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape())) {
                 // issue a parse error for the escape
@@ -997,11 +1005,13 @@ namespace ts {
 
         template<typename T>
         T nextTokenAnd(function<T()> func) {
+            ZoneScoped;
             nextToken();
             return func();
         }
 
         void initializeState(string _fileName, string _sourceText, ScriptTarget _languageVersion, ScriptKind _scriptKind) {
+            ZoneScoped;
 //            NodeConstructor = objectAllocator.getNodeConstructor();
 //            TokenConstructor = objectAllocator.getTokenConstructor();
 //            IdentifierConstructor = objectAllocator.getIdentifierConstructor();
@@ -1040,12 +1050,13 @@ namespace ts {
 
             // Initialize and prime the scanner before parsing the source elements.
             scanner.setText(sourceText);
-            scanner.setOnError([this](auto ...a) { scanError(a...); });
+//            scanner.setOnError([this](auto ...a) { scanError(a...); });
             scanner.setScriptTarget(languageVersion);
             scanner.setLanguageVariant(languageVariant);
         }
 
         void clearState() {
+            ZoneScoped;
             // Clear out the text the scanner is pointing at, so it doesn't keep anything alive unnecessarily.
             scanner.clearCommentDirectives();
             scanner.setText("");
@@ -1209,44 +1220,52 @@ namespace ts {
 //            // binding.
 //            setParentRecursive(rootNode, /*incremental*/ true);
 //        }
-//
-//        function createSourceFile(
-//            fileName: string,
-//            languageVersion: ScriptTarget,
-//            scriptKind: ScriptKind,
-//            isDeclarationFile: boolean,
-//            statements: readonly Statement[],
-//            endOfFileToken: EndOfFileToken,
-//            flags: NodeFlags,
-//            setExternalModuleIndicator: (sourceFile: SourceFile) => void): SourceFile {
-//            // code from createNode is inlined here so createNode won't have to deal with special case of creating source files
-//            // this is quite rare comparing to other nodes and createNode should be as fast as possible
-//            auto sourceFile = factory.createSourceFile(statements, endOfFileToken, flags);
-//            setTextRangePosWidth(sourceFile, 0, sourceText.length);
-//            setFields(sourceFile);
-//
-//            // If we parsed this as an external module, it may contain top-level await
-//            if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & TransformFlags.ContainsPossibleTopLevelAwait) {
+
+        shared<SourceFile> createSourceFile(
+                string fileName,
+                ScriptTarget languageVersion,
+                ScriptKind scriptKind,
+                bool isDeclarationFile,
+                shared<NodeArray> statements,
+                shared<EndOfFileToken> endOfFileToken,
+                int flags,
+                function<void(shared<SourceFile>)> setExternalModuleIndicator
+        ) {
+            // code from createNode is inlined here so createNode won't have to deal with special case of creating source files
+            // this is quite rare comparing to other nodes and createNode should be as fast as possible
+            auto sourceFile = factory.createSourceFile(statements, endOfFileToken, flags);
+            setTextRangePosEnd(sourceFile, 0, sourceText.size());
+            sourceFile->text = sourceText;
+
+//                sourceFile.bindDiagnostics = [];
+//                sourceFile.bindSuggestionDiagnostics = undefined;
+            sourceFile->languageVersion = languageVersion;
+            sourceFile->fileName = fileName;
+            sourceFile->languageVariant = getLanguageVariant(scriptKind);
+            sourceFile->isDeclarationFile = isDeclarationFile;
+            sourceFile->scriptKind = scriptKind;
+            setExternalModuleIndicator(sourceFile);
+            sourceFile->setExternalModuleIndicator = setExternalModuleIndicator;
+
+            // If we parsed this as an external module, it may contain top-level await
+            if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile->transformFlags & (int) TransformFlags::ContainsPossibleTopLevelAwait) {
+                throw runtime_error("not implemented");
 //                sourceFile = reparseTopLevelAwait(sourceFile);
-//                setFields(sourceFile);
-//            }
-//
-//            return sourceFile;
-//
-//            function setFields(sourceFile: SourceFile) {
-//                sourceFile.text = sourceText;
+
+                sourceFile->text = sourceText;
 //                sourceFile.bindDiagnostics = [];
 //                sourceFile.bindSuggestionDiagnostics = undefined;
-//                sourceFile.languageVersion = languageVersion;
-//                sourceFile.fileName = fileName;
-//                sourceFile.languageVariant = getLanguageVariant(scriptKind);
-//                sourceFile.isDeclarationFile = isDeclarationFile;
-//                sourceFile.scriptKind = scriptKind;
-//
-//                setExternalModuleIndicator(sourceFile);
-//                sourceFile.setExternalModuleIndicator = setExternalModuleIndicator;
-//            }
-//        }
+                sourceFile->languageVersion = languageVersion;
+                sourceFile->fileName = fileName;
+                sourceFile->languageVariant = getLanguageVariant(scriptKind);
+                sourceFile->isDeclarationFile = isDeclarationFile;
+                sourceFile->scriptKind = scriptKind;
+                setExternalModuleIndicator(sourceFile);
+                sourceFile->setExternalModuleIndicator = setExternalModuleIndicator;
+            }
+
+            return sourceFile;
+        }
 
         void setContextFlag(bool val, int flag) {
             if (val) {
@@ -1340,6 +1359,7 @@ namespace ts {
         }
         template<typename T>
         T speculationHelper(const function<T()> &callback, SpeculationKind speculationKind) {
+            ZoneScoped;
             // Keep track of the state we'll need to rollback to if lookahead fails (or if the
             // caller asked us to always reset our state).
             auto saveToken = currentToken;
@@ -1363,7 +1383,7 @@ namespace ts {
 
             // If our callback returned something 'falsy' or we're just looking ahead,
             // then unconditionally restore us to where we were.
-            if (!(bool)result || (speculationKind != SpeculationKind::TryParse)) {
+            if (!(bool) result || (speculationKind != SpeculationKind::TryParse)) {
                 currentToken = saveToken;
                 if (speculationKind != SpeculationKind::Reparse) {
                     parseDiagnostics.resize(saveParseDiagnosticsLength);
@@ -1380,6 +1400,7 @@ namespace ts {
          */
         template<typename T>
         T lookAhead(const function<T()> &callback) {
+            ZoneScoped;
             return speculationHelper<T>(callback, SpeculationKind::Lookahead);
         }
 
@@ -1428,13 +1449,11 @@ namespace ts {
         void parseErrorForInvalidName(DiagnosticMessage nameDiagnostic, DiagnosticMessage blankDiagnostic, SyntaxKind tokenIfBlankName) {
             if (token() == tokenIfBlankName) {
                 parseErrorAtCurrentToken(blankDiagnostic);
-            }
-            else {
+            } else {
                 parseErrorAtCurrentToken(nameDiagnostic, scanner.getTokenValue());
             }
         }
 
-
         /**
          * Provides a better error message than the generic "';' expected" if possible for
          * known common variants of a missing semicolon, such as from a mispelled names.
@@ -1554,8 +1573,7 @@ namespace ts {
             if (type && !canParseSemicolon()) {
                 if (initializer) {
                     parseErrorAtCurrentToken(Diagnostics::_0_expected, tokenToString(SyntaxKind::SemicolonToken));
-                }
-                else {
+                } else {
                     parseErrorAtCurrentToken(Diagnostics::Expected_for_property_initializer);
                 }
                 return;
@@ -1592,6 +1610,7 @@ namespace ts {
 
         template<class T>
         shared<T> finishNode(shared<T> node, int pos, optional<int> end = {}) {
+            ZoneScoped;
             setTextRangePosEnd(node, pos, end ? *end : scanner.getStartPos());
             if (contextFlags) {
                 node->flags |= contextFlags;
@@ -1610,6 +1629,7 @@ namespace ts {
 
         template<class T>
         shared<T> parseTokenNode() {
+            ZoneScoped;
             auto pos = getNodePos();
             auto kind = token();
             nextToken();
@@ -1619,6 +1639,7 @@ namespace ts {
 //        function parseOptionalToken<TKind extends SyntaxKind>(t: TKind): Token<TKind>;
         template<class T>
         sharedOpt<T> parseOptionalToken(SyntaxKind t) {
+            ZoneScoped;
             if (token() == t) {
                 return parseTokenNode<T>();
             }
@@ -1650,12 +1671,19 @@ namespace ts {
             return tryParseSemicolon() || parseExpected(SyntaxKind::SemicolonToken);
         }
 
-        NodeArray createNodeArray(vector<shared<Node>> elements, int pos, optional<int> end = {}, optional<bool> hasTrailingComma = {}) {
+        shared<NodeArray> createNodeArray(const vector<shared<Node>> &elements, int pos, optional<int> end = {}, optional<bool> hasTrailingComma = {}) {
             auto array = factory.createNodeArray(elements, hasTrailingComma);
             setTextRangePosEnd(array, pos, end ? *end : scanner.getStartPos());
             return array;
         }
 
+        //for empty call: createNodeArray(nullptr)
+        shared<NodeArray> createNodeArray(vector<shared<Node>> *elements, int pos, optional<int> end = {}, optional<bool> hasTrailingComma = {}) {
+            auto array = factory.createNodeArray(elements ? *elements : (vector<shared<Node>>) {}, hasTrailingComma);
+            setTextRangePosEnd(array, pos, end ? *end : scanner.getStartPos());
+            return array;
+        }
+
 //        function createMissingNode<T extends Node>(kind: T["kind"], reportAtCurrentPosition: false, optional<DiagnosticMessage> diagnosticMessage, arg0?: any): T;
 //        function createMissingNode<T extends Node>(kind: T["kind"], reportAtCurrentPosition: boolean, diagnosticMessage: DiagnosticMessage, arg0?: any): T;
         template<typename T>
@@ -1674,14 +1702,15 @@ namespace ts {
                     kind == SyntaxKind::StringLiteral ? factory.createStringLiteral("", /*isSingleQuote*/ {}) :
                     kind == SyntaxKind::MissingDeclaration ? factory.createMissingDeclaration() :
                     factory.createToken<Node>(kind);
-            auto a = finishNode(result, pos);
+            return to<T>(finishNode(result, pos));
         }
 
         string internIdentifier(string text) {
             auto identifier = get(identifiers, text);
             if (!identifier) {
                 identifier = text;
-                set(identifiers, text, *identifier);
+                identifiers[text] = text;
+//                set(identifiers, text, *identifier);
             }
             return *identifier;
         }
@@ -1713,7 +1742,7 @@ namespace ts {
          * of invoking the callback is returned from this function.
          */
         template<typename T>
-        T tryParse(function<T()> callback) {
+        T tryParse(const function<T()> &callback) {
             return speculationHelper<T>(callback, SpeculationKind::TryParse);
         }
 
@@ -1732,7 +1761,7 @@ namespace ts {
             return token() == SyntaxKind::ClassKeyword || token() == SyntaxKind::FunctionKeyword ||
                    token() == SyntaxKind::InterfaceKeyword ||
                    (token() == SyntaxKind::AbstractKeyword && lookAhead<bool>(CALLBACK(nextTokenIsClassKeywordOnSameLine)) ||
-                   (token() == SyntaxKind::AsyncKeyword && lookAhead<bool>(CALLBACK(nextTokenIsFunctionKeywordOnSameLine))));
+                    (token() == SyntaxKind::AsyncKeyword && lookAhead<bool>(CALLBACK(nextTokenIsFunctionKeywordOnSameLine))));
         }
 
         bool isLiteralPropertyName() {
@@ -1796,7 +1825,7 @@ namespace ts {
         }
 
         bool parseContextualModifier(SyntaxKind t) {
-            return token() == t && tryParse<bool>(CALLBACK(CALLBACK(nextTokenCanFollowModifier)));
+            return token() == t && tryParse<bool>(CALLBACK(nextTokenCanFollowModifier));
         }
 
         bool nextTokenIsOpenParenOrLessThanOrDot() {
@@ -2334,6 +2363,7 @@ namespace ts {
 
         // True if positioned at the start of a list element
         bool isListElement(ParsingContext parsingContext, bool inErrorRecovery) {
+            ZoneScoped;
             auto node = currentNode(parsingContext);
             if (node) {
                 return true;
@@ -2887,6 +2917,7 @@ namespace ts {
 
         template<class T>
         sharedOpt<T> parseListElement(ParsingContext parsingContext, function<shared<T>()> parseElement) {
+            ZoneScoped;
             auto node = currentNode(parsingContext);
             if (node) {
                 return consumeNode(node);
@@ -2896,8 +2927,9 @@ namespace ts {
         }
 
         // Parses a list of elements
-        NodeArray parseList(ParsingContext kind, function<shared<Node>()> parseElement) {
-            auto saveParsingContext = parsingContext;
+        shared<NodeArray> parseList(ParsingContext kind, const function<shared<Node>()> &parseElement) {
+            ZoneScoped;
+            int saveParsingContext = parsingContext;
             parsingContext |= 1 << (int) kind;
             vector<shared<Node>> list;
 
@@ -2905,7 +2937,9 @@ namespace ts {
 
             while (!isListTerminator(kind)) {
                 if (isListElement(kind, /*inErrorRecovery*/ false)) {
-                    list.push_back(parseListElement(kind, parseElement));
+                    auto n = parseListElement(kind, parseElement);
+                    if (!n) throw runtime_error("No node given");
+                    list.push_back(n);
 
                     continue;
                 }
@@ -2922,7 +2956,8 @@ namespace ts {
 //        // Parses a comma-delimited list of elements
 //        function parseDelimitedList<T extends Node>(kind: ParsingContext, parseElement: () => T, considerSemicolonAsDelimiter?: boolean): NodeArray<T>;
 //        function parseDelimitedList<T extends Node | undefined>(kind: ParsingContext, parseElement: () => T, considerSemicolonAsDelimiter?: boolean): NodeArray<NonNullable<T>> | undefined;
-        optional<NodeArray> parseDelimitedList(ParsingContext kind, function<sharedOpt<Node>()> parseElement, optional<bool> considerSemicolonAsDelimiter = {}) {
+        sharedOpt<NodeArray> parseDelimitedList(ParsingContext kind, function<sharedOpt<Node>()> parseElement, optional<bool> considerSemicolonAsDelimiter = {}) {
+            ZoneScoped;
             auto saveParsingContext = parsingContext;
             parsingContext |= 1 << (int) kind;
             vector<shared<Node>> list;
@@ -2935,7 +2970,7 @@ namespace ts {
                     auto result = parseListElement(kind, parseElement);
                     if (!result) {
                         parsingContext = saveParsingContext;
-                        return nullopt;
+                        return nullptr;
                     }
                     list.push_back(result);
                     commaStart = scanner.getTokenPos();
@@ -2995,14 +3030,14 @@ namespace ts {
 //            isMissingList: true;
 //        }
 
-        NodeArray createMissingList() {
-            auto list = createNodeArray({}, getNodePos());
-            list.isMissingList = true;
+        shared<NodeArray> createMissingList() {
+            auto list = createNodeArray(nullptr, getNodePos());
+            list->isMissingList = true;
             return list;
         }
 
-        bool isMissingList(NodeArray &arr) {
-            return arr.isMissingList;
+        bool isMissingList(const shared<NodeArray> &arr) {
+            return arr->isMissingList;
         }
 
         // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
@@ -3076,6 +3111,7 @@ namespace ts {
 
         template<typename T>
         T doInsideOfContext(/*NodeFlags*/int context, function<T()> func) {
+            ZoneScoped;
             // contextFlagsToSet will contain only the context flags that
             // are not currently set that we need to temporarily enable.
             // We don't just blindly reset to the previous flags to ensure
@@ -3098,37 +3134,37 @@ namespace ts {
 
         template<typename T>
         T allowInAnd(const function<T()> &func) {
-            return doOutsideOfContext<T>((int)NodeFlags::DisallowInContext, func);
+            return doOutsideOfContext<T>((int) NodeFlags::DisallowInContext, func);
         }
 
         template<typename T>
         T disallowInAnd(const function<T()> &func) {
-            return doInsideOfContext<T>((int)NodeFlags::DisallowInContext, func);
+            return doInsideOfContext<T>((int) NodeFlags::DisallowInContext, func);
         }
 
         template<typename T>
         T allowConditionalTypesAnd(const function<T()> &func) {
-            return doOutsideOfContext<T>((int)NodeFlags::DisallowConditionalTypesContext, func);
+            return doOutsideOfContext<T>((int) NodeFlags::DisallowConditionalTypesContext, func);
         }
         template<typename T>
         T disallowConditionalTypesAnd(const function<T()> &func) {
-            return doInsideOfContext<T>((int)NodeFlags::DisallowConditionalTypesContext, func);
+            return doInsideOfContext<T>((int) NodeFlags::DisallowConditionalTypesContext, func);
         }
         template<typename T>
         T doInYieldContext(const function<T()> &func) {
-            return doInsideOfContext<T>((int)NodeFlags::YieldContext, func);
+            return doInsideOfContext<T>((int) NodeFlags::YieldContext, func);
         }
         template<typename T>
         T doInDecoratorContext(const function<T()> &func) {
-            return doInsideOfContext<T>((int)NodeFlags::DecoratorContext, func);
+            return doInsideOfContext<T>((int) NodeFlags::DecoratorContext, func);
         }
         template<typename T>
         T doInAwaitContext(const function<T()> &func) {
-            return doInsideOfContext<T>((int)NodeFlags::AwaitContext, func);
+            return doInsideOfContext<T>((int) NodeFlags::AwaitContext, func);
         }
         template<typename T>
         T doOutsideOfAwaitContext(const function<T()> &func) {
-            return doOutsideOfContext<T>((int)NodeFlags::AwaitContext, func);
+            return doOutsideOfContext<T>((int) NodeFlags::AwaitContext, func);
         }
         template<typename T>
         T doInYieldAndAwaitContext(const function<T()> &func) {
@@ -3185,7 +3221,7 @@ namespace ts {
             );
         }
 
-        NodeArray parseTemplateSpans(bool isTaggedTemplate) {
+        shared<NodeArray> parseTemplateSpans(bool isTaggedTemplate) {
             auto pos = getNodePos();
             vector<shared<Node>> list;
             sharedOpt<TemplateSpan> node;
@@ -3202,7 +3238,7 @@ namespace ts {
             }
             shared<Node> fragment = parseLiteralLikeNode(token());
 //            Debug::asserts(fragment.kind == SyntaxKind::TemplateHead, "Template head has wrong token kind");
-            return dynamic_pointer_cast<TemplateHead>(fragment);
+            return reinterpret_pointer_cast<TemplateHead>(fragment);
         }
 
         shared<TemplateExpression> parseTemplateExpression(bool isTaggedTemplate) {
@@ -3229,11 +3265,11 @@ namespace ts {
                 }
                 dotPos = getNodePos();
                 entity = finishNode(
-                    factory.createQualifiedName(
-                        entity,
-                        parseRightSideOfDot(allowReservedWords, /* allowPrivateIdentifiers */ false)
-                    ),
-                    pos
+                        factory.createQualifiedName(
+                                entity,
+                                parseRightSideOfDot(allowReservedWords, /* allowPrivateIdentifiers */ false)
+                        ),
+                        pos
                 );
             }
             return entity;
@@ -3246,21 +3282,21 @@ namespace ts {
             return parseEntityName(/*allowReservedWords*/ true, Diagnostics::Type_expected);
         }
 
-        optional<NodeArray> parseTypeArgumentsOfTypeReference() {
+        sharedOpt<NodeArray> parseTypeArgumentsOfTypeReference() {
             if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() == SyntaxKind::LessThanToken) {
                 return parseBracketedList(ParsingContext::TypeArguments, CALLBACK(parseType), SyntaxKind::LessThanToken, SyntaxKind::GreaterThanToken);
             }
-            return nullopt;
+            return nullptr;
         }
 
         shared<TypeReferenceNode> parseTypeReference() {
             auto pos = getNodePos();
             return finishNode(
-                factory.createTypeReferenceNode(
-                    parseEntityNameOfTypeReference(),
-                    parseTypeArgumentsOfTypeReference()
-                ),
-                pos
+                    factory.createTypeReferenceNode(
+                            parseEntityNameOfTypeReference(),
+                            parseTypeArgumentsOfTypeReference()
+                    ),
+                    pos
             );
         }
 
@@ -3271,11 +3307,11 @@ namespace ts {
                     return nodeIsMissing(node->to<TypeReferenceNode>().typeName);
                 case SyntaxKind::FunctionType:
                 case SyntaxKind::ConstructorType: {
-                    auto f = dynamic_pointer_cast<FunctionOrConstructorTypeNodeBase>(node);
+                    auto f = reinterpret_pointer_cast<FunctionOrConstructorTypeNodeBase>(node);
                     return isMissingList(f->parameters) || typeHasArrowFunctionBlockingParseError(f->type);
                 }
                 case SyntaxKind::ParenthesizedType:
-                    return typeHasArrowFunctionBlockingParseError(reinterpret_cast<ParenthesizedTypeNode&>(node).type);
+                    return typeHasArrowFunctionBlockingParseError(reinterpret_cast<ParenthesizedTypeNode &>(node).type);
                 default:
                     return false;
             }
@@ -3400,7 +3436,7 @@ namespace ts {
             parseExpected(SyntaxKind::TypeOfKeyword);
             auto entityName = parseEntityName(/*allowReservedWords*/ true);
             // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
-            optional<NodeArray> typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : nullopt;
+            sharedOpt<NodeArray> typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : nullptr;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
 
@@ -3442,8 +3478,7 @@ namespace ts {
             return false;
         }
 
-
-        shared<PropertyAccessExpression> parsePropertyAccessExpressionRest(int pos, shared<LeftHandSideExpression> expression, sharedOpt<QuestionDotToken> questionDotToken) {
+        shared<PropertyAccessExpression> parsePropertyAccessExpressionRest(int pos, const shared<LeftHandSideExpression> &expression, const sharedOpt<QuestionDotToken> &questionDotToken) {
             auto name = parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true);
             auto isOptionalChain = questionDotToken || tryReparseOptionalChain(expression);
             auto propertyAccess = isOptionalChain ?
@@ -3455,14 +3490,14 @@ namespace ts {
             return finishNode(propertyAccess, pos);
         }
 
-        shared<ElementAccessExpression> parseElementAccessExpressionRest(int pos, shared<LeftHandSideExpression> expression, sharedOpt<QuestionDotToken> questionDotToken) {
+        shared<ElementAccessExpression> parseElementAccessExpressionRest(int pos, const shared<LeftHandSideExpression> &expression, const sharedOpt<QuestionDotToken> &questionDotToken) {
             sharedOpt<Expression> argumentExpression;
             if (token() == SyntaxKind::CloseBracketToken) {
                 argumentExpression = createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ true, Diagnostics::An_element_access_expression_should_take_an_argument);
             } else {
                 auto argument = allowInAnd<shared<Expression>>(CALLBACK(parseExpression));
                 if (isStringOrNumericLiteralLike(argument)) {
-                    dynamic_pointer_cast<LiteralExpression>(argument)->text = internIdentifier(dynamic_pointer_cast<LiteralExpression>(argument)->text);
+                    reinterpret_pointer_cast<LiteralExpression>(argument)->text = internIdentifier(reinterpret_pointer_cast<LiteralExpression>(argument)->text);
                 }
                 argumentExpression = argument;
             }
@@ -3475,7 +3510,7 @@ namespace ts {
             return finishNode(factory.createElementAccessExpression(expression, argumentExpression), pos);
         }
 
-        shared<TaggedTemplateExpression> parseTaggedTemplateRest(int pos, shared<LeftHandSideExpression> tag, sharedOpt<QuestionDotToken> questionDotToken, optional<NodeArray> typeArguments = {}) {
+        shared<TaggedTemplateExpression> parseTaggedTemplateRest(int pos, shared<LeftHandSideExpression> tag, sharedOpt<QuestionDotToken> questionDotToken, sharedOpt<NodeArray> typeArguments = {}) {
             shared<Node> templateLiteral = token() == SyntaxKind::NoSubstitutionTemplateLiteral ?
                                            (shared<Node>) (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) :
                                            (shared<Node>) parseTemplateExpression(/*isTaggedTemplate*/ true);
@@ -3485,7 +3520,7 @@ namespace ts {
                     templateLiteral
             );
             if (questionDotToken || tag->flags & (int) NodeFlags::OptionalChain) {
-                tagExpression->flags |= (int)NodeFlags::OptionalChain;
+                tagExpression->flags |= (int) NodeFlags::OptionalChain;
             }
             tagExpression->questionDotToken = questionDotToken;
             return finishNode(tagExpression, pos);
@@ -3503,28 +3538,28 @@ namespace ts {
             return !isStartOfExpression();
         }
 
-        optional<NodeArray> parseTypeArgumentsInExpression() {
-            if ((contextFlags & (int)NodeFlags::JavaScriptFile) != 0) {
+        sharedOpt<NodeArray> parseTypeArgumentsInExpression() {
+            if ((contextFlags & (int) NodeFlags::JavaScriptFile) != 0) {
                 // TypeArguments must not be parsed in JavaScript files to avoid ambiguity with binary operators.
-                return nullopt;
+                return nullptr;
             }
 
             if (reScanLessThanToken() != SyntaxKind::LessThanToken) {
-                return nullopt;
+                return nullptr;
             }
             nextToken();
 
             auto typeArguments = parseDelimitedList(ParsingContext::TypeArguments, CALLBACK(parseType));
             if (!parseExpected(SyntaxKind::GreaterThanToken)) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
-                return nullopt;
+                return nullptr;
             }
 
             // We successfully parsed a type argument list. The next token determines whether we want to
             // treat it as such. If the type argument list is followed by `(` or a template literal, as in
             // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
             // it as a relational expression.
-            return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : nullopt;
+            return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : nullptr;
         }
 
         shared<MemberExpression> parseMemberExpressionRest(int pos, shared<LeftHandSideExpression> expression, bool allowOptionalChain) {
@@ -3563,14 +3598,14 @@ namespace ts {
                         expression = finishNode(factory.createNonNullExpression(expression), pos);
                         continue;
                     }
-                    auto typeArguments = tryParse<optional<NodeArray>>(CALLBACK(CALLBACK(parseTypeArgumentsInExpression)));
+                    auto typeArguments = tryParse<sharedOpt<NodeArray>>(CALLBACK(parseTypeArgumentsInExpression));
                     if (typeArguments) {
                         expression = finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
                         continue;
                     }
                 }
 
-                return dynamic_pointer_cast<MemberExpression>(expression);
+                return reinterpret_pointer_cast<MemberExpression>(expression);
             }
         }
 
@@ -3596,7 +3631,8 @@ namespace ts {
             return finishNode(factory.createDecorator(expression), pos);
         }
 
-        optional<NodeArray> parseDecorators() {
+        sharedOpt<NodeArray> parseDecorators() {
+            ZoneScoped;
             auto pos = getNodePos();
             sharedOpt<Node> decorator;
             vector<shared<Node>> list;
@@ -3604,7 +3640,7 @@ namespace ts {
             while (decorator = tryParseDecorator()) {
                 list = append(list, decorator);
             }
-            if (list.empty()) return nullopt;
+            if (list.empty()) return nullptr;
             return createNodeArray(list, pos);
         }
 
@@ -3613,6 +3649,7 @@ namespace ts {
         }
 
         sharedOpt<Modifier> tryParseModifier(bool permitInvalidConstAsModifier = false, bool stopOnStartOfClassStaticBlock = false, bool hasSeenStaticModifier = false) {
+            ZoneScoped;
             auto pos = getNodePos();
             auto kind = token();
 
@@ -3642,7 +3679,8 @@ namespace ts {
          *
          * In such situations, 'permitInvalidConstAsModifier' should be set to true.
          */
-        optional<NodeArray> parseModifiers(bool permitInvalidConstAsModifier = false, bool stopOnStartOfClassStaticBlock = false) {
+        sharedOpt<NodeArray> parseModifiers(bool permitInvalidConstAsModifier = false, bool stopOnStartOfClassStaticBlock = false) {
+            ZoneScoped;
             auto pos = getNodePos();
             auto hasSeenStatic = false;
             vector<shared<Node>> list;
@@ -3652,7 +3690,7 @@ namespace ts {
                 list = append(list, modifier);
             }
             if (!list.empty()) return createNodeArray(list, pos);
-            return nullopt;
+            return nullptr;
         }
 
         bool isParameterNameStart() {
@@ -3662,7 +3700,8 @@ namespace ts {
             return isBindingIdentifier() || token() == SyntaxKind::OpenBracketToken || token() == SyntaxKind::OpenBraceToken;
         }
 
-        shared<Node> parseNameOfParameter(optional<NodeArray> modifiers) {
+        shared<Node> parseNameOfParameter(const sharedOpt<NodeArray> &modifiers) {
+            ZoneScoped;
             // FormalParameter [Yield,Await]:
             //      BindingElement[?Yield,?Await]
             auto name = parseIdentifierOrPattern(Diagnostics::Private_identifiers_cannot_be_used_as_parameters);
@@ -3681,6 +3720,7 @@ namespace ts {
         }
 
         sharedOpt<Expression> parseInitializer() {
+            ZoneScoped;
             return parseOptional(SyntaxKind::EqualsToken) ? parseAssignmentExpressionOrHigher() : nullptr;
         }
 
@@ -3694,7 +3734,7 @@ namespace ts {
             //      BindingElement[?Yield,?Await]
 
             // Decorators are parsed in the outer [Await] context, the rest of the parameter is parsed in the function's [Await] context.
-            auto decorators = inOuterAwaitContext ? doInAwaitContext<optional<NodeArray>>(CALLBACK(parseDecorators)) : parseDecorators();
+            auto decorators = inOuterAwaitContext ? doInAwaitContext<sharedOpt<NodeArray>>(CALLBACK(parseDecorators)) : parseDecorators();
 
             if (token() == SyntaxKind::ThisKeyword) {
                 auto node = factory.createParameterDeclaration(
@@ -3751,15 +3791,13 @@ namespace ts {
             return parseParameterWorker(inOuterAwaitContext, /*allowAmbiguity*/ false);
         }
 
-        bool shouldParseReturnType(SyntaxKind returnToken, bool isType){
+        bool shouldParseReturnType(SyntaxKind returnToken, bool isType) {
             if (returnToken == SyntaxKind::EqualsGreaterThanToken) {
                 parseExpected(returnToken);
                 return true;
-            }
-            else if (parseOptional(SyntaxKind::ColonToken)) {
+            } else if (parseOptional(SyntaxKind::ColonToken)) {
                 return true;
-            }
-            else if (isType && token() == SyntaxKind::EqualsGreaterThanToken) {
+            } else if (isType && token() == SyntaxKind::EqualsGreaterThanToken) {
                 // This is easy to get backward, especially in type contexts, so parse the type anyway
                 parseErrorAtCurrentToken(Diagnostics::_0_expected, tokenToString(SyntaxKind::ColonToken));
                 nextToken();
@@ -3770,7 +3808,7 @@ namespace ts {
 
 //        function parseReturnType(returnToken: SyntaxKind::EqualsGreaterThanToken, isType: boolean): TypeNode;
 //        function parseReturnType(returnToken: SyntaxKind::ColonToken | SyntaxKind::EqualsGreaterThanToken, isType: boolean): TypeNode | undefined;
-         sharedOpt<TypeNode> parseReturnType(SyntaxKind returnToken, bool isType) {
+        sharedOpt<TypeNode> parseReturnType(SyntaxKind returnToken, bool isType) {
             if (shouldParseReturnType(returnToken, isType)) {
                 return allowConditionalTypesAnd<shared<TypeNode>>(CALLBACK(parseTypeOrTypePredicate));
             }
@@ -3804,13 +3842,13 @@ namespace ts {
             parseExpected(SyntaxKind::OpenBracketToken);
             auto elements = parseDelimitedList(ParsingContext::ArrayBindingElements, CALLBACK(parseArrayBindingElement));
             parseExpected(SyntaxKind::CloseBracketToken);
-            return finishNode(factory.createArrayBindingPattern(*elements), pos);
+            return finishNode(factory.createArrayBindingPattern(elements), pos);
         }
 
         string getTemplateLiteralRawText(SyntaxKind kind) {
             auto isLast = kind == SyntaxKind::NoSubstitutionTemplateLiteral || kind == SyntaxKind::TemplateTail;
             auto tokenText = scanner.getTokenText();
-            return tokenText.substr(1, tokenText.size() - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2));
+            return substring(tokenText, 1, tokenText.size() - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2));
         }
 
         shared<LiteralLike> parseLiteralLikeNode(SyntaxKind kind) {
@@ -3858,7 +3896,7 @@ namespace ts {
             return finishNode(factory.createComputedPropertyName(expression), pos);
         }
 
-        string internPrivateIdentifier(string text) {
+        string internPrivateIdentifier(const string &text) {
             auto privateIdentifier = get(privateIdentifiers, text);
             if (!privateIdentifier) {
                 privateIdentifier = text;
@@ -3894,6 +3932,7 @@ namespace ts {
         }
 
         shared<BindingElement> parseObjectBindingElement() {
+            ZoneScoped;
             auto pos = getNodePos();
             auto dotDotDotToken = parseOptionalToken<DotDotDotToken>(SyntaxKind::DotDotDotToken);
             auto tokenIsIdentifier = isBindingIdentifier();
@@ -3915,10 +3954,11 @@ namespace ts {
             parseExpected(SyntaxKind::OpenBraceToken);
             auto elements = parseDelimitedList(ParsingContext::ObjectBindingElements, CALLBACK(parseObjectBindingElement));
             parseExpected(SyntaxKind::CloseBraceToken);
-            return finishNode(factory.createObjectBindingPattern(*elements), pos);
+            return finishNode(factory.createObjectBindingPattern(elements), pos);
         }
 
         shared<UnionNode<Identifier, BindingPattern>> parseIdentifierOrPattern(optional<DiagnosticMessage> privateIdentifierDiagnosticMessage = {}) {
+            ZoneScoped;
             if (token() == SyntaxKind::OpenBracketToken) {
                 return parseArrayBindingPattern();
             }
@@ -3990,8 +4030,8 @@ namespace ts {
             return token() == SyntaxKind::NewKeyword || (token() == SyntaxKind::AbstractKeyword && lookAhead<bool>(CALLBACK(nextTokenIsNewKeyword)));
         }
 
-        optional<NodeArray> parseModifiersForConstructorType() {
-            optional<NodeArray> modifiers;
+        sharedOpt<NodeArray> parseModifiersForConstructorType() {
+            sharedOpt<NodeArray> modifiers;
             if (token() == SyntaxKind::AbstractKeyword) {
                 auto pos = getNodePos();
                 nextToken();
@@ -4090,19 +4130,19 @@ namespace ts {
             return expression;
         }
 
-        NodeArray parseBracketedList(ParsingContext kind, function<shared<Node>()> parseElement, SyntaxKind open, SyntaxKind close) {
+        shared<NodeArray> parseBracketedList(ParsingContext kind, function<shared<Node>()> parseElement, SyntaxKind open, SyntaxKind close) {
             if (parseExpected(open)) {
                 auto result = parseDelimitedList(kind, parseElement);
                 parseExpected(close);
-                return *result;
+                return result;
             }
 
             return createMissingList();
         }
 
-        optional<NodeArray> tryParseTypeArguments() {
+        sharedOpt<NodeArray> tryParseTypeArguments() {
             if (token() == SyntaxKind::LessThanToken) return parseBracketedList(ParsingContext::TypeArguments, CALLBACK(parseType), SyntaxKind::LessThanToken, SyntaxKind::GreaterThanToken);
-            return nullopt;
+            return nullptr;
         }
 
         SyntaxKind scanJsxAttributeValue() {
@@ -4199,7 +4239,7 @@ namespace ts {
             return false;
         }
 
-        NodeArray parseJsxChildren(shared<NodeUnion(JsxOpeningElement, JsxOpeningFragment)> openingTag) {
+        shared<NodeArray> parseJsxChildren(shared<NodeUnion(JsxOpeningElement, JsxOpeningFragment)> openingTag) {
             vector<shared<Node>> list;
             auto listPos = getNodePos();
             auto saveParsingContext = parsingContext;
@@ -4260,11 +4300,11 @@ namespace ts {
             auto _opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
             sharedOpt<Expression> result; //JsxElement | JsxSelfClosingElement | JsxFragment
             if (_opening->kind == SyntaxKind::JsxOpeningElement) {
-                auto opening = dynamic_pointer_cast<JsxOpeningElement>(_opening);
+                auto opening = reinterpret_pointer_cast<JsxOpeningElement>(_opening);
                 auto children = parseJsxChildren(opening);
                 sharedOpt<JsxClosingElement> closingElement; // JsxClosingElement;
 
-                auto lastChild = children.list[children.length() - 1];
+                auto lastChild = children->list[children->length() - 1];
                 if (lastChild && lastChild->kind == SyntaxKind::JsxElement
                     && !tagNamesAreEquivalent(getTagName(lastChild->to<JsxElement>().openingElement), getTagName(lastChild->to<JsxElement>().closingElement))
                     && tagNamesAreEquivalent(getTagName(opening), getTagName(lastChild->to<JsxElement>().closingElement))) {
@@ -4272,7 +4312,7 @@ namespace ts {
                     // restructure (<div>(...<span>...</div>)) --> (<div>(...<span>...</>)</div>)
                     // (no need to error; the parent will error)
                     auto jsxElement = lastChild->to<JsxElement>();
-                    auto end = jsxElement.children.end;
+                    auto end = jsxElement.children->end;
                     auto newLast = finishNode(factory.createJsxElement(
                                                       jsxElement.openingElement,
                                                       jsxElement.children,
@@ -4280,9 +4320,9 @@ namespace ts {
                                               jsxElement.openingElement->pos,
                                               end);
 
-                    auto c = children.slice(0, children.length() - 1);
+                    auto c = children->slice(0, children->length() - 1);
                     c.push_back(newLast);
-                    children = createNodeArray(c, children.pos, end);
+                    children = createNodeArray(c, children->pos, end);
                     closingElement = jsxElement.closingElement;
                 } else {
                     closingElement = parseJsxClosingElement(opening, inExpressionContext);
@@ -4298,7 +4338,7 @@ namespace ts {
                 }
                 result = finishNode(factory.createJsxElement(opening, children, closingElement), pos);
             } else if (_opening->kind == SyntaxKind::JsxOpeningFragment) {
-                auto opening = dynamic_pointer_cast<JsxOpeningFragment>(_opening);
+                auto opening = reinterpret_pointer_cast<JsxOpeningFragment>(_opening);
                 result = finishNode(factory.createJsxFragment(opening, parseJsxChildren(opening), parseJsxClosingFragment(inExpressionContext)), pos);
             } else {
                 assert(_opening->kind == SyntaxKind::JsxSelfClosingElement);
@@ -4378,7 +4418,7 @@ namespace ts {
                 return finishNode(factory.createJsxOpeningFragment(), pos);
             }
             auto tagName = parseJsxElementName();
-            optional<NodeArray> typeArguments = (contextFlags & (int) NodeFlags::JavaScriptFile) == 0 ? tryParseTypeArguments() : nullopt;
+            sharedOpt<NodeArray> typeArguments = (contextFlags & (int) NodeFlags::JavaScriptFile) == 0 ? tryParseTypeArguments() : nullptr;
             auto attributes = parseJsxAttributes();
 
             sharedOpt<Expression> node;
@@ -4414,16 +4454,16 @@ namespace ts {
             return nextToken() == SyntaxKind::DotToken;
         }
 
-        optional<NodeArray> parseTypeParameters() {
+        sharedOpt<NodeArray> parseTypeParameters() {
             if (token() == SyntaxKind::LessThanToken) {
                 return parseBracketedList(ParsingContext::TypeParameters, CALLBACK(parseTypeParameter), SyntaxKind::LessThanToken, SyntaxKind::GreaterThanToken);
             }
-            return nullopt;
+            return nullptr;
         }
 
 //        function parseParametersWorker(SignatureFlags flags, allowAmbiguity: true): NodeArray<ParameterDeclaration>;
 //        function parseParametersWorker(SignatureFlags flags, allowAmbiguity: false): NodeArray<ParameterDeclaration> | undefined;
-        optional<NodeArray> parseParametersWorker(int flags, bool allowAmbiguity) {
+        sharedOpt<NodeArray> parseParametersWorker(int flags, bool allowAmbiguity) {
             // FormalParameters [Yield,Await]: (modified)
             //      [empty]
             //      FormalParameterList[?Yield,Await]
@@ -4440,12 +4480,12 @@ namespace ts {
             auto savedYieldContext = inYieldContext();
             auto savedAwaitContext = inAwaitContext();
 
-            setYieldContext(!!(flags & (int)SignatureFlags::Yield));
-            setAwaitContext(!!(flags & (int)SignatureFlags::Await));
+            setYieldContext(!!(flags & (int) SignatureFlags::Yield));
+            setAwaitContext(!!(flags & (int) SignatureFlags::Await));
 
-            optional<NodeArray> parameters = flags & (int)SignatureFlags::JSDoc ?
-                              NodeArray() : //we ignore JSDoc, parseDelimitedList(ParsingContext::JSDocParameters, parseJSDocParameter) :
-                              parseDelimitedList(ParsingContext::Parameters, [this, &allowAmbiguity, savedAwaitContext]()->sharedOpt<Node> { return allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext); });
+            sharedOpt<NodeArray> parameters = flags & (int) SignatureFlags::JSDoc ?
+                                              make_shared<NodeArray>() : //we ignore JSDoc, parseDelimitedList(ParsingContext::JSDocParameters, parseJSDocParameter) :
+                                              parseDelimitedList(ParsingContext::Parameters, [this, &allowAmbiguity, savedAwaitContext]()->sharedOpt<Node> { return allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext); });
 
             setYieldContext(savedYieldContext);
             setAwaitContext(savedAwaitContext);
@@ -4453,7 +4493,7 @@ namespace ts {
             return parameters;
         }
 
-        NodeArray parseParameters(int flags) {
+        shared<NodeArray> parseParameters(int flags) {
             // FormalParameters [Yield,Await]: (modified)
             //      [empty]
             //      FormalParameterList[?Yield,Await]
@@ -4473,11 +4513,11 @@ namespace ts {
 
             auto parameters = parseParametersWorker(flags, /*allowAmbiguity*/ true);
             parseExpected(SyntaxKind::CloseParenToken);
-            return *parameters;
+            return parameters;
         }
 
-        NodeArray parseParameters(SignatureFlags flags) {
-            return parseParameters((int)flags);
+        shared<NodeArray> parseParameters(SignatureFlags flags) {
+            return parseParameters((int) flags);
         }
 
         shared<NodeUnion(CallSignatureDeclaration, ConstructSignatureDeclaration)> parseSignatureMember(SyntaxKind kind) {
@@ -4492,8 +4532,8 @@ namespace ts {
             auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ true);
             parseTypeMemberSemicolon();
             shared<Node> node = kind == SyntaxKind::CallSignature
-                        ? (shared<Node>)factory.createCallSignature(typeParameters, parameters, type)
-                        : (shared<Node>)factory.createConstructSignature(typeParameters, parameters, type);
+                                ? (shared<Node>) factory.createCallSignature(typeParameters, parameters, type)
+                                : (shared<Node>) factory.createConstructSignature(typeParameters, parameters, type);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
 
@@ -4509,8 +4549,8 @@ namespace ts {
             if (lastError) {
                 auto b = createDetachedDiagnostic(fileName, openPosition, 1, Diagnostics::The_parser_expected_to_find_a_1_to_match_the_0_token_here, {tokenToString(openKind), tokenToString(closeKind)});
                 addRelatedInfo(
-                    *lastError,
-                    {b}
+                        *lastError,
+                        {b}
                 );
             }
         }
@@ -4531,8 +4571,7 @@ namespace ts {
                 }
 
                 return result;
-            }
-            else {
+            } else {
                 auto statements = createMissingList();
                 return withJSDoc(finishNode(factory.createBlock(statements, /*multiLine*/ false), pos), hasJSDoc);
             }
@@ -4540,10 +4579,10 @@ namespace ts {
 
         shared<Block> parseFunctionBlock(int flags, optional<DiagnosticMessage> diagnosticMessage = {}) {
             auto savedYieldContext = inYieldContext();
-            setYieldContext(!!(flags & (int)SignatureFlags::Yield));
+            setYieldContext(!!(flags & (int) SignatureFlags::Yield));
 
             auto savedAwaitContext = inAwaitContext();
-            setAwaitContext(!!(flags & (int)SignatureFlags::Await));
+            setAwaitContext(!!(flags & (int) SignatureFlags::Await));
 
             auto savedTopLevel = topLevel;
             topLevel = false;
@@ -4555,7 +4594,7 @@ namespace ts {
                 setDecoratorContext(/*val*/ false);
             }
 
-            auto block = parseBlock(!!(flags & (int)SignatureFlags::IgnoreMissingOpenBrace), diagnosticMessage);
+            auto block = parseBlock(!!(flags & (int) SignatureFlags::IgnoreMissingOpenBrace), diagnosticMessage);
 
             if (saveDecoratorContext) {
                 setDecoratorContext(/*val*/ true);
@@ -4577,15 +4616,15 @@ namespace ts {
             return parseFunctionBlock(flags, diagnosticMessage);
         }
 
-        shared<Node> parseAccessorDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers, SyntaxKind kind) {
+        shared<Node> parseAccessorDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers, SyntaxKind kind) {
             auto name = parsePropertyName();
             auto typeParameters = parseTypeParameters();
             auto parameters = parseParameters(SignatureFlags::None);
             auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
-            auto body = parseFunctionBlockOrSemicolon((int)SignatureFlags::None);
+            auto body = parseFunctionBlockOrSemicolon((int) SignatureFlags::None);
             shared<Node> node = kind == SyntaxKind::GetAccessor
-                ? (shared<Node>)factory.createGetAccessorDeclaration(decorators, modifiers, name, parameters, type, body)
-                : (shared<Node>)factory.createSetAccessorDeclaration(decorators, modifiers, name, parameters, body);
+                                ? (shared<Node>) factory.createGetAccessorDeclaration(decorators, modifiers, name, parameters, type, body)
+                                : (shared<Node>) factory.createSetAccessorDeclaration(decorators, modifiers, name, parameters, body);
             // Keep track of `typeParameters` (for both) and `type` (for setters) if they were parsed those indicate grammar errors
             if (node->is<GetAccessorDeclaration>()) {
                 node->to<GetAccessorDeclaration>().typeParameters = typeParameters;
@@ -4625,11 +4664,9 @@ namespace ts {
                 if (isIdentifier()) {
                     return true;
                 }
-            }
-            else if (!isIdentifier()) {
+            } else if (!isIdentifier()) {
                 return false;
-            }
-            else {
+            } else {
                 // Skip the identifier
                 nextToken();
             }
@@ -4657,15 +4694,15 @@ namespace ts {
             return token() == SyntaxKind::OpenBracketToken && lookAhead<bool>(CALLBACK(isUnambiguouslyIndexSignature));
         }
 
-        shared<IndexSignatureDeclaration> parseIndexSignatureDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers) {
-            auto parameters = parseBracketedList(ParsingContext::Parameters, [this]() -> shared<Node>{ return parseParameter(/*inOuterAwaitContext*/ false); }, SyntaxKind::OpenBracketToken, SyntaxKind::CloseBracketToken);
+        shared<IndexSignatureDeclaration> parseIndexSignatureDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers) {
+            auto parameters = parseBracketedList(ParsingContext::Parameters, [this]()->shared<Node> { return parseParameter(/*inOuterAwaitContext*/ false); }, SyntaxKind::OpenBracketToken, SyntaxKind::CloseBracketToken);
             auto type = parseTypeAnnotation();
             parseTypeMemberSemicolon();
             auto node = factory.createIndexSignature(decorators, modifiers, parameters, type);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
 
-        shared<Node> parsePropertyOrMethodSignature(int pos, bool hasJSDoc, optional<NodeArray> modifiers) {
+        shared<Node> parsePropertyOrMethodSignature(int pos, bool hasJSDoc, sharedOpt<NodeArray> modifiers) {
             auto name = parsePropertyName();
             auto questionToken = parseOptionalToken<QuestionToken>(SyntaxKind::QuestionToken);
             shared<Node> node;
@@ -4676,8 +4713,7 @@ namespace ts {
                 auto parameters = parseParameters(SignatureFlags::Type);
                 auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ true);
                 node = factory.createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type);
-            }
-            else {
+            } else {
                 auto type = parseTypeAnnotation();
                 auto p = factory.createPropertySignature(modifiers, name, questionToken, type);
                 // Although type literal properties cannot not have initializers, we attempt
@@ -4714,8 +4750,8 @@ namespace ts {
             return parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers);
         }
 
-        NodeArray parseObjectTypeMembers() {
-            NodeArray members;
+        shared<NodeArray> parseObjectTypeMembers() {
+            shared<NodeArray> members;
             if (parseExpected(SyntaxKind::OpenBraceToken)) {
                 members = parseList(ParsingContext::TypeMembers, CALLBACK(parseTypeMember));
                 parseExpected(SyntaxKind::CloseBraceToken);
@@ -4747,20 +4783,20 @@ namespace ts {
             return doOutsideOfContext<shared<Expression>>(disallowInAndDecoratorContext, CALLBACK(parseArgumentOrArrayLiteralElement));
         }
 
-        NodeArray parseArgumentList() {
+        shared<NodeArray> parseArgumentList() {
             parseExpected(SyntaxKind::OpenParenToken);
             auto result = parseDelimitedList(ParsingContext::ArgumentExpressions, CALLBACK(parseArgumentExpression));
             parseExpected(SyntaxKind::CloseParenToken);
-            return *result;
+            return result;
         }
 
         shared<LeftHandSideExpression> parseCallExpressionRest(int pos, shared<LeftHandSideExpression> expression) {
             while (true) {
                 expression = parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true);
-                optional<NodeArray> typeArguments;
+                sharedOpt<NodeArray> typeArguments;
                 auto questionDotToken = parseOptionalToken<QuestionDotToken>(SyntaxKind::QuestionDotToken);
                 if (questionDotToken) {
-                    typeArguments = tryParse<optional<NodeArray>>(CALLBACK(parseTypeArgumentsInExpression));
+                    typeArguments = tryParse<sharedOpt<NodeArray>>(CALLBACK(parseTypeArgumentsInExpression));
                     if (isTemplateStartOfTaggedTemplate()) {
                         expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
                         continue;
@@ -4774,8 +4810,8 @@ namespace ts {
                     }
                     auto argumentList = parseArgumentList();
                     auto callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
-                        factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
-                        factory.createCallExpression(expression, typeArguments, argumentList);
+                                    factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
+                                    factory.createCallExpression(expression, typeArguments, argumentList);
                     expression = finishNode(callExpr, pos);
                     continue;
                 }
@@ -4808,34 +4844,33 @@ namespace ts {
             return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos);
         }
 
-
         shared<MethodDeclaration> parseMethodDeclaration(
-            int pos,
-            bool hasJSDoc,
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
-            sharedOpt<AsteriskToken> asteriskToken,
-            shared<Node> name,
-            sharedOpt<QuestionToken> questionToken,
-            sharedOpt<ExclamationToken> exclamationToken,
-            optional<DiagnosticMessage> diagnosticMessage = {}
+                int pos,
+                bool hasJSDoc,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
+                sharedOpt<AsteriskToken> asteriskToken,
+                shared<Node> name,
+                sharedOpt<QuestionToken> questionToken,
+                sharedOpt<ExclamationToken> exclamationToken,
+                optional<DiagnosticMessage> diagnosticMessage = {}
         ) {
             auto isGenerator = asteriskToken ? SignatureFlags::Yield : SignatureFlags::None;
             auto isAsync = some(modifiers, isAsyncModifier) ? SignatureFlags::Await : SignatureFlags::None;
             auto typeParameters = parseTypeParameters();
-            auto parameters = parseParameters((int)isGenerator | (int)isAsync);
+            auto parameters = parseParameters((int) isGenerator | (int) isAsync);
             auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
-            auto body = parseFunctionBlockOrSemicolon((int)isGenerator | (int)isAsync, diagnosticMessage);
+            auto body = parseFunctionBlockOrSemicolon((int) isGenerator | (int) isAsync, diagnosticMessage);
             auto node = factory.createMethodDeclaration(
-                decorators,
-                modifiers,
-                asteriskToken,
-                name,
-                questionToken,
-                typeParameters,
-                parameters,
-                type,
-                body
+                    decorators,
+                    modifiers,
+                    asteriskToken,
+                    name,
+                    questionToken,
+                    typeParameters,
+                    parameters,
+                    type,
+                    body
             );
             // An exclamation token on a method is invalid syntax and will be handled by the grammar checker
             node->exclamationToken = exclamationToken;
@@ -4843,6 +4878,7 @@ namespace ts {
         }
 
         shared<ObjectLiteralElementLike> parseObjectLiteralElement() {
+            ZoneScoped;
             auto pos = getNodePos();
             auto hasJSDoc = hasPrecedingJSDocComment();
 
@@ -4890,8 +4926,7 @@ namespace ts {
                 n->questionToken = questionToken;
                 n->exclamationToken = exclamationToken;
                 node = n;
-            }
-            else {
+            } else {
                 parseExpected(SyntaxKind::ColonToken);
                 auto initializer = allowInAnd<shared<Expression>>(CALLBACK(parseAssignmentExpressionOrHigher));
                 auto n = factory.createPropertyAssignment(name, initializer);
@@ -4935,15 +4970,15 @@ namespace ts {
             auto asteriskToken = parseOptionalToken<AsteriskToken>(SyntaxKind::AsteriskToken);
             auto isGenerator = asteriskToken ? SignatureFlags::Yield : SignatureFlags::None;
             auto isAsync = some(modifiers, isAsyncModifier) ? SignatureFlags::Await : SignatureFlags::None;
-            auto name = (int)isGenerator && (int)isAsync ? doInYieldAndAwaitContext<sharedOpt<Identifier>>(CALLBACK(parseOptionalBindingIdentifier)) :
-                        (int)isGenerator ? doInYieldContext<sharedOpt<Identifier>>(CALLBACK(parseOptionalBindingIdentifier)) :
-                        (int)isAsync ? doInAwaitContext<sharedOpt<Identifier>>(CALLBACK(parseOptionalBindingIdentifier)) :
-                parseOptionalBindingIdentifier();
+            auto name = (int) isGenerator && (int) isAsync ? doInYieldAndAwaitContext<sharedOpt<Identifier>>(CALLBACK(parseOptionalBindingIdentifier)) :
+                        (int) isGenerator ? doInYieldContext<sharedOpt<Identifier>>(CALLBACK(parseOptionalBindingIdentifier)) :
+                        (int) isAsync ? doInAwaitContext<sharedOpt<Identifier>>(CALLBACK(parseOptionalBindingIdentifier)) :
+                        parseOptionalBindingIdentifier();
 
             auto typeParameters = parseTypeParameters();
-            auto parameters = parseParameters((int)isGenerator | (int)isAsync);
+            auto parameters = parseParameters((int) isGenerator | (int) isAsync);
             auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
-            auto body = parseFunctionBlock((int)isGenerator | (int)isAsync);
+            auto body = parseFunctionBlock((int) isGenerator | (int) isAsync);
 
             setDecoratorContext(savedDecoratorContext);
 
@@ -4962,15 +4997,15 @@ namespace ts {
             // - class with name 'implements'
             // 'isImplementsClause' helps to disambiguate between these two cases
             return isBindingIdentifier() && !isImplementsClause()
-                ? createIdentifier(isBindingIdentifier())
-                : nullptr;
+                   ? createIdentifier(isBindingIdentifier())
+                   : nullptr;
         }
 
         shared<ExpressionWithTypeArguments> parseExpressionWithTypeArguments() {
             auto pos = getNodePos();
             auto expression = parseLeftHandSideExpressionOrHigher();
             if (expression->kind == SyntaxKind::ExpressionWithTypeArguments) {
-                return dynamic_pointer_cast<ExpressionWithTypeArguments>(expression);
+                return reinterpret_pointer_cast<ExpressionWithTypeArguments>(expression);
             }
             auto typeArguments = tryParseTypeArguments();
             return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
@@ -4982,10 +5017,10 @@ namespace ts {
             Debug::asserts(tok == SyntaxKind::ExtendsKeyword || tok == SyntaxKind::ImplementsKeyword); // isListElement() should ensure this.
             nextToken();
             auto types = parseDelimitedList(ParsingContext::HeritageClauseElement, CALLBACK(parseExpressionWithTypeArguments));
-            return finishNode(factory.createHeritageClause(tok, *types), pos);
+            return finishNode(factory.createHeritageClause(tok, types), pos);
         }
 
-        optional<NodeArray> parseHeritageClauses() {
+        sharedOpt<NodeArray> parseHeritageClauses() {
             // ClassTail[Yield,Await] : (Modified) See 14.5
             //      ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
 
@@ -4993,7 +5028,7 @@ namespace ts {
                 return parseList(ParsingContext::HeritageClauses, CALLBACK(parseHeritageClause));
             }
 
-            return nullopt;
+            return nullptr;
         }
 
         shared<Block> parseClassStaticBlockBody() {
@@ -5011,7 +5046,7 @@ namespace ts {
             return body;
         }
 
-        shared<ClassStaticBlockDeclaration> parseClassStaticBlockDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers) {
+        shared<ClassStaticBlockDeclaration> parseClassStaticBlockDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers) {
             parseExpectedToken<StaticKeyword>(SyntaxKind::StaticKeyword);
             auto body = parseClassStaticBlockBody();
             return withJSDoc(finishNode(factory.createClassStaticBlockDeclaration(decorators, modifiers, body), pos), hasJSDoc);
@@ -5022,7 +5057,7 @@ namespace ts {
                 return parseExpected(SyntaxKind::ConstructorKeyword);
             }
             if (token() == SyntaxKind::StringLiteral && lookAhead<SyntaxKind>(CALLBACK(nextToken)) == SyntaxKind::OpenParenToken) {
-                return tryParse<bool>([this]() -> bool {
+                return tryParse<bool>([this]()->bool {
                     auto literalNode = parseLiteralNode();
                     return literalNode->text == "constructor";
                 });
@@ -5030,14 +5065,13 @@ namespace ts {
             return false;
         }
 
-
-        sharedOpt<ConstructorDeclaration> tryParseConstructorDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers) {
-            return tryParse<sharedOpt<ConstructorDeclaration>>([this, &decorators, &modifiers, &pos, &hasJSDoc]() -> sharedOpt<ConstructorDeclaration> {
+        sharedOpt<ConstructorDeclaration> tryParseConstructorDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers) {
+            return tryParse<sharedOpt<ConstructorDeclaration>>([this, &decorators, &modifiers, &pos, &hasJSDoc]()->sharedOpt<ConstructorDeclaration> {
                 if (parseConstructorName()) {
                     auto typeParameters = parseTypeParameters();
                     auto parameters = parseParameters(SignatureFlags::None);
                     auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
-                    auto body = parseFunctionBlockOrSemicolon((int)SignatureFlags::None, Diagnostics::or_expected);
+                    auto body = parseFunctionBlockOrSemicolon((int) SignatureFlags::None, Diagnostics::or_expected);
                     auto node = factory.createConstructorDeclaration(decorators, modifiers, parameters, body);
                     // Attach `typeParameters` and `type` if they exist so that we can report them in the grammar checker.
                     node->typeParameters = typeParameters;
@@ -5053,26 +5087,26 @@ namespace ts {
         }
 
         shared<PropertyDeclaration> parsePropertyDeclaration(
-            int pos,
-            bool hasJSDoc,
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers,
-            shared<Node> name,
-            sharedOpt<QuestionToken> questionToken
+                int pos,
+                bool hasJSDoc,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers,
+                shared<Node> name,
+                sharedOpt<QuestionToken> questionToken
         ) {
             sharedOpt<ExclamationToken> exclamationToken = !questionToken && !scanner.hasPrecedingLineBreak() ? parseOptionalToken<ExclamationToken>(SyntaxKind::ExclamationToken) : nullptr;
             auto type = parseTypeAnnotation();
-            auto initializer = doOutsideOfContext<sharedOpt<Expression>>((int)NodeFlags::YieldContext | (int)NodeFlags::AwaitContext | (int)NodeFlags::DisallowInContext, CALLBACK(parseInitializer));
+            auto initializer = doOutsideOfContext<sharedOpt<Expression>>((int) NodeFlags::YieldContext | (int) NodeFlags::AwaitContext | (int) NodeFlags::DisallowInContext, CALLBACK(parseInitializer));
             parseSemicolonAfterPropertyName(name, type, initializer);
-            auto node = factory.createPropertyDeclaration(decorators, modifiers, name, questionToken ? (shared<Node>)questionToken : (shared<Node>)exclamationToken, type, initializer);
+            auto node = factory.createPropertyDeclaration(decorators, modifiers, name, questionToken ? (shared<Node>) questionToken : (shared<Node>) exclamationToken, type, initializer);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
 
         shared<Node> parsePropertyOrMethodDeclaration(
-            int pos,
-            bool hasJSDoc,
-            optional<NodeArray> decorators,
-            optional<NodeArray> modifiers
+                int pos,
+                bool hasJSDoc,
+                sharedOpt<NodeArray> decorators,
+                sharedOpt<NodeArray> modifiers
         ) {
             auto asteriskToken = parseOptionalToken<AsteriskToken>(SyntaxKind::AsteriskToken);
             auto name = parsePropertyName();
@@ -5128,13 +5162,12 @@ namespace ts {
                 auto isAmbient = some(modifiers, CALLBACK(isDeclareModifier));
                 if (isAmbient && modifiers) {
                     for (auto &m: modifiers->list) {
-                        m->flags |= (int)NodeFlags::Ambient;
+                        m->flags |= (int) NodeFlags::Ambient;
                     }
-                    return doInsideOfContext<shared<Node>>((int)NodeFlags::Ambient, [&]() {
+                    return doInsideOfContext<shared<Node>>((int) NodeFlags::Ambient, [&]() {
                         return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
                     });
-                }
-                else {
+                } else {
                     return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
                 }
             }
@@ -5149,11 +5182,11 @@ namespace ts {
             throw runtime_error("Should not have attempted to parse class member declaration.");
         }
 
-        NodeArray parseClassMembers() {
+        shared<NodeArray> parseClassMembers() {
             return parseList(ParsingContext::ClassMembers, CALLBACK(parseClassElement));
         }
 
-        shared<NodeUnion(ClassLikeDeclaration)> parseClassDeclarationOrExpression(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers, SyntaxKind kind) {
+        shared<NodeUnion(ClassLikeDeclaration)> parseClassDeclarationOrExpression(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers, SyntaxKind kind) {
             auto savedAwaitContext = inAwaitContext();
             parseExpected(SyntaxKind::ClassKeyword);
 
@@ -5163,25 +5196,24 @@ namespace ts {
             if (some(modifiers, isExportModifier)) setAwaitContext(/*value*/ true);
             auto heritageClauses = parseHeritageClauses();
 
-            NodeArray members;
+            shared<NodeArray> members;
             if (parseExpected(SyntaxKind::OpenBraceToken)) {
                 // ClassTail[Yield,Await] : (Modified) See 14.5
                 //      ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt }
                 members = parseClassMembers();
                 parseExpected(SyntaxKind::CloseBraceToken);
-            }
-            else {
+            } else {
                 members = createMissingList();
             }
             setAwaitContext(savedAwaitContext);
             auto node = kind == SyntaxKind::ClassDeclaration
-                ? (shared<Node>)factory.createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members)
-                : (shared<Node>)factory.createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members);
+                        ? (shared<Node>) factory.createClassDeclaration(decorators, modifiers, name, typeParameters, heritageClauses, members)
+                        : (shared<Node>) factory.createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
 
         shared<ClassExpression> parseClassExpression() {
-            return dynamic_pointer_cast<ClassExpression>(parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ {}, /*modifiers*/ {}, SyntaxKind::ClassExpression));
+            return reinterpret_pointer_cast<ClassExpression>(parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ {}, /*modifiers*/ {}, SyntaxKind::ClassExpression));
         }
 
         shared<PrimaryExpression> parseNewExpressionOrNewDotTarget() {
@@ -5193,13 +5225,13 @@ namespace ts {
             }
             auto expressionPos = getNodePos();
             shared<Expression> expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), /*allowOptionalChain*/ false);
-            optional<NodeArray> typeArguments;
+            sharedOpt<NodeArray> typeArguments;
             // Absorb type arguments into NewExpression when preceding expression is ExpressionWithTypeArguments
             if (expression->kind == SyntaxKind::ExpressionWithTypeArguments) {
                 typeArguments = expression->to<ExpressionWithTypeArguments>().typeArguments;
                 expression = expression->to<ExpressionWithTypeArguments>().expression;
             }
-            optional<NodeArray> argumentList;
+            sharedOpt<NodeArray> argumentList;
             if (token() == SyntaxKind::OpenParenToken) argumentList = parseArgumentList();
 
             return finishNode(factory.createNewExpression(expression, typeArguments, argumentList), pos);
@@ -5255,6 +5287,7 @@ namespace ts {
         }
 
         shared<MemberExpression> parseMemberExpressionOrHigher() {
+            ZoneScoped;
             // Note: to make our lives simpler, we decompose the NewExpression productions and
             // place ObjectCreationExpression and FunctionExpression into PrimaryExpression.
             // like so:
@@ -5308,11 +5341,12 @@ namespace ts {
         }
 
         shared<MemberExpression> parseSuperExpression() {
+            ZoneScoped;
             auto pos = getNodePos();
             auto expression = parseTokenNode<PrimaryExpression>();
             if (token() == SyntaxKind::LessThanToken) {
                 auto startPos = getNodePos();
-                auto typeArguments = tryParse<optional<NodeArray>>(CALLBACK(parseTypeArgumentsInExpression));
+                auto typeArguments = tryParse<sharedOpt<NodeArray>>(CALLBACK(parseTypeArgumentsInExpression));
                 if (typeArguments) {
                     parseErrorAt(startPos, getNodePos(), Diagnostics::super_may_not_use_type_arguments);
                 }
@@ -5330,6 +5364,7 @@ namespace ts {
         }
 
         shared<LeftHandSideExpression> parseLeftHandSideExpressionOrHigher() {
+            ZoneScoped;
             // Original Ecma:
             // LeftHandSideExpression: See 11.2
             //      NewExpression
@@ -5396,12 +5431,14 @@ namespace ts {
         }
 
         shared<Expression> parseBinaryExpressionOrHigher(int precedence) {
+            ZoneScoped;
             auto pos = getNodePos();
             auto leftOperand = parseUnaryExpressionOrHigher();
             return parseBinaryExpressionRest(precedence, leftOperand, pos);
         }
 
         shared<Expression> parseBinaryExpressionRest(int precedence, shared<Expression> leftOperand, int pos) {
+            ZoneScoped;
             while (true) {
                 // We either have a binary operator here, or we're finished.  We call
                 // reScanGreaterToken so that we merge token sequences like > and = into >=
@@ -5431,8 +5468,8 @@ namespace ts {
                 //      a ** b - c
                 //             ^token; leftOperand = b. Return b to the caller as a rightOperand
                 auto consumeCurrentOperator = token() == SyntaxKind::AsteriskAsteriskToken ?
-                    newPrecedence >= (int)precedence :
-                    newPrecedence > (int)precedence;
+                                              newPrecedence >= (int) precedence :
+                                              newPrecedence > (int) precedence;
 
                 if (!consumeCurrentOperator) {
                     break;
@@ -5450,13 +5487,11 @@ namespace ts {
                     // by a function call to 'as' with the argument 'Bar'
                     if (scanner.hasPrecedingLineBreak()) {
                         break;
-                    }
-                    else {
+                    } else {
                         nextToken();
                         leftOperand = makeAsExpression(leftOperand, parseType());
                     }
-                }
-                else {
+                } else {
 
                     leftOperand = makeBinaryExpression(leftOperand, parseTokenNode<Node>(), parseBinaryExpressionOrHigher(newPrecedence), pos);
                 }
@@ -5477,6 +5512,7 @@ namespace ts {
          * In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
          */
         shared<Expression> parseUpdateExpression() {
+            ZoneScoped;
             if (token() == SyntaxKind::PlusPlusToken || token() == SyntaxKind::MinusMinusToken) {
                 auto pos = getNodePos();
                 return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd<shared<LeftHandSideExpression>>(CALLBACK(parseLeftHandSideExpressionOrHigher))), pos);
@@ -5550,6 +5586,7 @@ namespace ts {
          *      9) [+Await] await UnaryExpression[?yield]
          */
         shared<UnaryExpression> parseSimpleUnaryExpression() {
+            ZoneScoped;
             switch (token()) {
                 case SyntaxKind::PlusToken:
                 case SyntaxKind::MinusToken:
@@ -5573,7 +5610,7 @@ namespace ts {
                     }
                     // falls through
                 default:
-                    return dynamic_pointer_cast<UnaryExpression>(parseUpdateExpression());
+                    return reinterpret_pointer_cast<UnaryExpression>(parseUpdateExpression());
             }
         }
 
@@ -5586,7 +5623,6 @@ namespace ts {
             return finishNode(factory.createTypeAssertion(type, expression), pos);
         }
 
-
         /**
          * Parse ES7 exponential expression and await expression
          *
@@ -5596,6 +5632,7 @@ namespace ts {
          *
          */
         shared<Expression> parseUnaryExpressionOrHigher() {
+            ZoneScoped;
             /**
              * ES7 UpdateExpression:
              *      1) LeftHandSideExpression[?Yield]
@@ -5680,8 +5717,8 @@ namespace ts {
             auto parameters = parseParameters(SignatureFlags::Type);
             auto type = parseReturnType(SyntaxKind::EqualsGreaterThanToken, /*isType*/ false);
             auto node = isConstructorType
-                        ? (shared<TypeNode>)factory.createConstructorTypeNode1(modifiers, typeParameters, parameters, type)
-                        : (shared<TypeNode>)factory.createFunctionTypeNode(typeParameters, parameters, type);
+                        ? (shared<TypeNode>) factory.createConstructorTypeNode1(modifiers, typeParameters, parameters, type)
+                        : (shared<TypeNode>) factory.createFunctionTypeNode(typeParameters, parameters, type);
             if (!isConstructorType) node->modifiers = modifiers;
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -5721,7 +5758,6 @@ namespace ts {
             return token() == SyntaxKind::DotToken ? nullptr : node;
         }
 
-
         shared<TypeNode> parseJSDocAllType() {
             throw runtime_error("JSDoc not supported");
 //            auto pos = getNodePos();
@@ -5735,7 +5771,7 @@ namespace ts {
                 nextToken();
             }
             shared<Expression> expression =
-                token() == SyntaxKind::TrueKeyword || token() == SyntaxKind::FalseKeyword || token() == SyntaxKind::NullKeyword ?
+                    token() == SyntaxKind::TrueKeyword || token() == SyntaxKind::FalseKeyword || token() == SyntaxKind::NullKeyword ?
                     parseTokenNode<Expression>() :
                     parseLiteralLikeNode(token());
             if (negative) {
@@ -5750,8 +5786,9 @@ namespace ts {
         }
 
         shared<AssertEntry> parseAssertEntry() {
+            ZoneScoped;
             auto pos = getNodePos();
-            shared<Node> name = tokenIsIdentifierOrKeyword(token()) ? (shared<Node>)parseIdentifierName() : (shared<Node>)parseLiteralLikeNode(SyntaxKind::StringLiteral);
+            shared<Node> name = tokenIsIdentifierOrKeyword(token()) ? (shared<Node>) parseIdentifierName() : (shared<Node>) parseLiteralLikeNode(SyntaxKind::StringLiteral);
             parseExpected(SyntaxKind::ColonToken);
             auto value = parseAssignmentExpressionOrHigher();
             return finishNode(factory.createAssertEntry(name, value), pos);
@@ -5770,14 +5807,13 @@ namespace ts {
                     auto lastError = lastOrUndefined(parseDiagnostics);
                     if (lastError && lastError->code == Diagnostics::_0_expected.code) {
                         addRelatedInfo(
-                            *lastError,
-                            {createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics::The_parser_expected_to_find_a_1_to_match_the_0_token_here, {"{", "}"})}
+                                *lastError,
+                                {createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics::The_parser_expected_to_find_a_1_to_match_the_0_token_here, {"{", "}"})}
                         );
                     }
                 }
-                return finishNode(factory.createAssertClause(*elements, multiLine), pos);
-            }
-            else {
+                return finishNode(factory.createAssertClause(elements, multiLine), pos);
+            } else {
                 auto elements = createNodeArray({}, getNodePos(), /*end*/ {}, /*hasTrailingComma*/ false);
                 return finishNode(factory.createAssertClause(elements, /*multiLine*/ false), pos);
             }
@@ -5795,16 +5831,16 @@ namespace ts {
                 auto lastError = lastOrUndefined(parseDiagnostics);
                 if (lastError && lastError->code == Diagnostics::_0_expected.code) {
                     addRelatedInfo(
-                        *lastError,
-                        {createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics::The_parser_expected_to_find_a_1_to_match_the_0_token_here, {"{", "}"})}
+                            *lastError,
+                            {createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics::The_parser_expected_to_find_a_1_to_match_the_0_token_here, {"{", "}"})}
                     );
                 }
             }
             return finishNode(factory.createImportTypeAssertionContainer(clause, multiLine), pos);
         }
 
-        shared<ImportTypeNode> parseImportType()  {
-            sourceFlags |= (int)NodeFlags::PossiblyContainsDynamicImport;
+        shared<ImportTypeNode> parseImportType() {
+            sourceFlags |= (int) NodeFlags::PossiblyContainsDynamicImport;
             auto pos = getNodePos();
             auto isTypeOf = parseOptional(SyntaxKind::TypeOfKeyword);
             parseExpected(SyntaxKind::ImportKeyword);
@@ -5862,7 +5898,7 @@ namespace ts {
             }
             auto type = parseTypeAnnotation();
             parseSemicolon();
-            auto members = parseList(ParsingContext::TypeMembers, [this]() {return parseTypeMember();});
+            auto members = parseList(ParsingContext::TypeMembers, [this]() { return parseTypeMember(); });
             parseExpected(SyntaxKind::CloseBraceToken);
             return finishNode(factory.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos);
         }
@@ -5912,10 +5948,10 @@ namespace ts {
         shared<TupleTypeNode> parseTupleType() {
             auto pos = getNodePos();
             return finishNode(
-                factory.createTupleTypeNode(
-                    parseBracketedList(ParsingContext::TupleElementTypes, CALLBACK(parseTupleElementNameOrTupleElementType), SyntaxKind::OpenBracketToken, SyntaxKind::CloseBracketToken)
-                ),
-                pos
+                    factory.createTupleTypeNode(
+                            parseBracketedList(ParsingContext::TupleElementTypes, CALLBACK(parseTupleElementNameOrTupleElementType), SyntaxKind::OpenBracketToken, SyntaxKind::CloseBracketToken)
+                    ),
+                    pos
             );
         }
 
@@ -5930,7 +5966,7 @@ namespace ts {
         shared<TypeNode> parseAssertsTypePredicate() {
             auto pos = getNodePos();
             auto assertsModifier = parseExpectedToken<AssertsKeyword>(SyntaxKind::AssertsKeyword);
-            shared<Node> parameterName = token() == SyntaxKind::ThisKeyword ? (shared<Node>)parseThisTypeNode() : (shared<Node>)parseIdentifier();
+            shared<Node> parameterName = token() == SyntaxKind::ThisKeyword ? (shared<Node>) parseThisTypeNode() : (shared<Node>) parseIdentifier();
             sharedOpt<TypeNode> type = parseOptional(SyntaxKind::IsKeyword) ? parseType() : nullptr;
             return finishNode(factory.createTypePredicateNode(assertsModifier, parameterName, type), pos);
         }
@@ -5938,34 +5974,33 @@ namespace ts {
         shared<TemplateLiteralTypeSpan> parseTemplateTypeSpan() {
             auto pos = getNodePos();
             return finishNode(
-                factory.createTemplateLiteralTypeSpan(
-                    parseType(),
-                    parseLiteralOfTemplateSpan(/*isTaggedTemplate*/ false)
-                ),
-                pos
+                    factory.createTemplateLiteralTypeSpan(
+                            parseType(),
+                            parseLiteralOfTemplateSpan(/*isTaggedTemplate*/ false)
+                    ),
+                    pos
             );
         }
 
-        NodeArray parseTemplateTypeSpans() {
+        shared<NodeArray> parseTemplateTypeSpans() {
             auto pos = getNodePos();
             vector<shared<Node>> list;
             shared<TemplateLiteralTypeSpan> node;
             do {
                 node = parseTemplateTypeSpan();
                 list.push_back(node);
-            }
-            while (node->literal->kind == SyntaxKind::TemplateMiddle);
+            } while (node->literal->kind == SyntaxKind::TemplateMiddle);
             return createNodeArray(list, pos);
         }
 
         shared<TemplateLiteralTypeNode> parseTemplateType() {
             auto pos = getNodePos();
             return finishNode(
-                factory.createTemplateLiteralType(
-                    parseTemplateHead(/*isTaggedTemplate*/ false),
-                    parseTemplateTypeSpans()
-                ),
-                pos
+                    factory.createTemplateLiteralType(
+                            parseTemplateHead(/*isTaggedTemplate*/ false),
+                            parseTemplateTypeSpans()
+                    ),
+                    pos
             );
         }
 
@@ -6021,8 +6056,7 @@ namespace ts {
                     auto thisKeyword = parseThisTypeNode();
                     if (token() == SyntaxKind::IsKeyword && !scanner.hasPrecedingLineBreak()) {
                         return parseThisTypePredicate(thisKeyword);
-                    }
-                    else {
+                    } else {
                         return thisKeyword;
                     }
                 }
@@ -6073,8 +6107,7 @@ namespace ts {
                             auto indexType = parseType();
                             parseExpected(SyntaxKind::CloseBracketToken);
                             type = finishNode(factory.createIndexedAccessTypeNode(type, indexType), pos);
-                        }
-                        else {
+                        } else {
                             parseExpected(SyntaxKind::CloseBracketToken);
                             type = finishNode(factory.createArrayTypeNode(type), pos);
                         }
@@ -6108,14 +6141,12 @@ namespace ts {
                 DiagnosticMessage diagnostic;
                 if (isFunctionTypeNode(type)) {
                     diagnostic = isInUnionType
-                        ? Diagnostics::Function_type_notation_must_be_parenthesized_when_used_in_a_union_type
-                        : Diagnostics::Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
-                }
-                else {
+                                 ? Diagnostics::Function_type_notation_must_be_parenthesized_when_used_in_a_union_type
+                                 : Diagnostics::Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
+                } else {
                     diagnostic = isInUnionType
-                        ? Diagnostics::Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type
-                        : Diagnostics::Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
-
+                                 ? Diagnostics::Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type
+                                 : Diagnostics::Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
                 }
                 parseErrorAtRange(type, diagnostic);
                 return type;
@@ -6124,9 +6155,9 @@ namespace ts {
         }
 
         shared<TypeNode> parseUnionOrIntersectionType(
-            SyntaxKind operatorKind,
-            function<shared<TypeNode>()> parseConstituentType,
-            function<shared<TypeNode>(NodeArray)> createTypeNode //: (types: NodeArray<TypeNode>) => UnionOrIntersectionTypeNode
+                SyntaxKind operatorKind,
+                function<shared<TypeNode>()> parseConstituentType,
+                function<shared<TypeNode>(shared<NodeArray>)> createTypeNode //: (types: NodeArray<TypeNode>) => UnionOrIntersectionTypeNode
         ) {
             auto pos = getNodePos();
             auto isUnionType = operatorKind == SyntaxKind::BarToken;
@@ -6247,8 +6278,7 @@ namespace ts {
             auto type = parseType();
             if (typePredicateVariable) {
                 return finishNode(factory.createTypePredicateNode(/*assertsModifier*/ {}, typePredicateVariable, type), pos);
-            }
-            else {
+            } else {
                 return type;
             }
         }
@@ -6259,6 +6289,7 @@ namespace ts {
         }
 
         shared<Expression> parseExpression() {
+            ZoneScoped;
             // Expression[in]:
             //      AssignmentExpression[in]
             //      Expression[in] , AssignmentExpression[in]
@@ -6316,6 +6347,7 @@ namespace ts {
         }
 
         shared<YieldExpression> parseYieldExpression() {
+            ZoneScoped;
             auto pos = getNodePos();
 
             // YieldExpression[In] :
@@ -6485,19 +6517,19 @@ namespace ts {
             return Tristate::False;
         }
 
-        optional<NodeArray> parseModifiersForArrowFunction() {
+        sharedOpt<NodeArray> parseModifiersForArrowFunction() {
             if (token() == SyntaxKind::AsyncKeyword) {
                 auto pos = getNodePos();
                 nextToken();
                 auto modifier = finishNode(factory.createToken<AsyncKeyword>(SyntaxKind::AsyncKeyword), pos);
                 return factory.createNodeArray<Node>({modifier}, pos);
             }
-            return nullopt;
+            return nullptr;
         }
 
         shared<Node> parseArrowFunctionExpressionBody(bool isAsync) {
             if (token() == SyntaxKind::OpenBraceToken) {
-                return parseFunctionBlock(isAsync ? (int)SignatureFlags::Await : (int)SignatureFlags::None);
+                return parseFunctionBlock(isAsync ? (int) SignatureFlags::Await : (int) SignatureFlags::None);
             }
 
             if (token() != SyntaxKind::SemicolonToken &&
@@ -6519,14 +6551,14 @@ namespace ts {
                 // up preemptively closing the containing construct.
                 //
                 // Note: even when 'IgnoreMissingOpenBrace' is passed, parseBody will still error.
-                return parseFunctionBlock((int)SignatureFlags::IgnoreMissingOpenBrace | (isAsync ? (int)SignatureFlags::Await : (int)SignatureFlags::None));
+                return parseFunctionBlock((int) SignatureFlags::IgnoreMissingOpenBrace | (isAsync ? (int) SignatureFlags::Await : (int) SignatureFlags::None));
             }
 
             auto savedTopLevel = topLevel;
             topLevel = false;
             auto node = isAsync
-                ? doInAwaitContext<shared<Expression>>(CALLBACK(parseAssignmentExpressionOrHigher))
-                : doOutsideOfAwaitContext<shared<Expression>>(CALLBACK(parseAssignmentExpressionOrHigher));
+                        ? doInAwaitContext<shared<Expression>>(CALLBACK(parseAssignmentExpressionOrHigher))
+                        : doOutsideOfAwaitContext<shared<Expression>>(CALLBACK(parseAssignmentExpressionOrHigher));
             topLevel = savedTopLevel;
             return node;
         }
@@ -6545,7 +6577,7 @@ namespace ts {
             // close paren.
             auto typeParameters = parseTypeParameters();
 
-            NodeArray parameters;
+            shared<NodeArray> parameters;
             if (!parseExpected(SyntaxKind::OpenParenToken)) {
                 if (!allowAmbiguity) {
                     return nullptr;
@@ -6553,13 +6585,13 @@ namespace ts {
                 parameters = createMissingList();
             } else {
                 if (!allowAmbiguity) {
-                    auto maybeParameters = parseParametersWorker((int)isAsync, allowAmbiguity);
+                    auto maybeParameters = parseParametersWorker((int) isAsync, allowAmbiguity);
                     if (!maybeParameters) {
                         return nullptr;
                     }
-                    parameters = *maybeParameters;
+                    parameters = maybeParameters;
                 } else {
-                    parameters = *parseParametersWorker((int)isAsync, allowAmbiguity);
+                    parameters = parseParametersWorker((int) isAsync, allowAmbiguity);
                 }
                 if (!parseExpected(SyntaxKind::CloseParenToken) && !allowAmbiguity) {
                     return nullptr;
@@ -6620,6 +6652,7 @@ namespace ts {
         }
 
         sharedOpt<Expression> tryParseParenthesizedArrowFunctionExpression() {
+            ZoneScoped;
             auto triState = isParenthesizedArrowFunctionExpression();
             if (triState == Tristate::False) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -6647,7 +6680,7 @@ namespace ts {
                     return Tristate::False;
                 }
                 // Check for un-parenthesized AsyncArrowFunction
-                auto expr = parseBinaryExpressionOrHigher((int)OperatorPrecedence::Lowest);
+                auto expr = parseBinaryExpressionOrHigher((int) OperatorPrecedence::Lowest);
                 if (!scanner.hasPrecedingLineBreak() && expr->kind == SyntaxKind::Identifier && token() == SyntaxKind::EqualsGreaterThanToken) {
                     return Tristate::True;
                 }
@@ -6656,16 +6689,17 @@ namespace ts {
             return Tristate::False;
         }
 
-        shared<ArrowFunction> parseSimpleArrowFunctionExpression(int pos, shared<Identifier> identifier, optional<NodeArray> asyncModifier)  {
+        shared<ArrowFunction> parseSimpleArrowFunctionExpression(int pos, shared<Identifier> identifier, sharedOpt<NodeArray> asyncModifier) {
+            ZoneScoped;
             Debug::asserts(token() == SyntaxKind::EqualsGreaterThanToken, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             auto parameter = factory.createParameterDeclaration(
-                /*decorators*/ {},
-                /*modifiers*/ {},
-                /*dotDotDotToken*/ {},
-                identifier,
-                /*questionToken*/ {},
-                /*type*/ {},
-                /*initializer*/ {}
+                    /*decorators*/ {},
+                    /*modifiers*/ {},
+                    /*dotDotDotToken*/ {},
+                                   identifier,
+                    /*questionToken*/ {},
+                    /*type*/ {},
+                    /*initializer*/ {}
             );
             finishNode(parameter, identifier->pos);
 
@@ -6678,12 +6712,13 @@ namespace ts {
         }
 
         sharedOpt<ArrowFunction> tryParseAsyncSimpleArrowFunctionExpression() {
+            ZoneScoped;
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() == SyntaxKind::AsyncKeyword) {
                 if (lookAhead<Tristate>(CALLBACK(isUnParenthesizedAsyncArrowFunctionWorker)) == Tristate::True) {
                     auto pos = getNodePos();
                     auto asyncModifier = parseModifiersForArrowFunction();
-                    auto expr = parseBinaryExpressionOrHigher((int)OperatorPrecedence::Lowest);
+                    auto expr = parseBinaryExpressionOrHigher((int) OperatorPrecedence::Lowest);
                     return parseSimpleArrowFunctionExpression(pos, to<Identifier>(expr), asyncModifier);
                 }
             }
@@ -6691,6 +6726,7 @@ namespace ts {
         }
 
         shared<Expression> parseConditionalExpressionRest(shared<Expression> leftOperand, int pos) {
+            ZoneScoped;
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             auto questionToken = parseOptionalToken<QuestionToken>(SyntaxKind::QuestionToken);
             if (!questionToken) {
@@ -6701,20 +6737,21 @@ namespace ts {
             // we do not that for the 'whenFalse' part.
             sharedOpt<ColonToken> colonToken;
             return finishNode(
-                factory.createConditionalExpression(
-                    leftOperand,
-                    questionToken,
-                    doOutsideOfContext<shared<Expression>>(disallowInAndDecoratorContext, CALLBACK(parseAssignmentExpressionOrHigher)),
-                    colonToken = parseExpectedToken<ColonToken>(SyntaxKind::ColonToken),
-                    nodeIsPresent(colonToken)
-                        ? parseAssignmentExpressionOrHigher()
-                        : createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ false, Diagnostics::_0_expected, tokenToString(SyntaxKind::ColonToken))
-                ),
-                pos
+                    factory.createConditionalExpression(
+                            leftOperand,
+                            questionToken,
+                            doOutsideOfContext<shared<Expression>>(disallowInAndDecoratorContext, CALLBACK(parseAssignmentExpressionOrHigher)),
+                            colonToken = parseExpectedToken<ColonToken>(SyntaxKind::ColonToken),
+                            nodeIsPresent(colonToken)
+                            ? parseAssignmentExpressionOrHigher()
+                            : createMissingNode<Identifier>(SyntaxKind::Identifier, /*reportAtCurrentPosition*/ false, Diagnostics::_0_expected, tokenToString(SyntaxKind::ColonToken))
+                    ),
+                    pos
             );
         }
 
         shared<Expression> parseAssignmentExpressionOrHigher() {
+            ZoneScoped;
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -6755,7 +6792,7 @@ namespace ts {
             // binary expression here, so we pass in the 'lowest' precedence here so that it matches
             // and consumes anything.
             auto pos = getNodePos();
-            auto expr = parseBinaryExpressionOrHigher((int)OperatorPrecedence::Lowest);
+            auto expr = parseBinaryExpressionOrHigher((int) OperatorPrecedence::Lowest);
 
             // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
@@ -7051,6 +7088,7 @@ namespace ts {
         }
 
         shared<VariableDeclaration> parseVariableDeclaration(optional<bool> allowExclamation = {}) {
+            ZoneScoped;
             auto pos = getNodePos();
             auto hasJSDoc = hasPrecedingJSDocComment();
             auto name = parseIdentifierOrPattern(Diagnostics::Private_identifiers_are_not_allowed_in_variable_declarations);
@@ -7070,6 +7108,7 @@ namespace ts {
         }
 
         shared<VariableDeclarationList> parseVariableDeclarationList(bool inForStatementInitializer) {
+            ZoneScoped;
             auto pos = getNodePos();
 
             int flags = 0;
@@ -7077,10 +7116,10 @@ namespace ts {
                 case SyntaxKind::VarKeyword:
                     break;
                 case SyntaxKind::LetKeyword:
-                    flags |= (int)NodeFlags::Let;
+                    flags |= (int) NodeFlags::Let;
                     break;
                 case SyntaxKind::ConstKeyword:
-                    flags |= (int)NodeFlags::Const;
+                    flags |= (int) NodeFlags::Const;
                     break;
                 default:
                     Debug::fail();
@@ -7097,18 +7136,17 @@ namespace ts {
             // So we need to look ahead to determine if 'of' should be treated as a keyword in
             // this context.
             // The checker will then give an error that there is an empty declaration list.
-            NodeArray declarations;
+            shared<NodeArray> declarations;
             if (token() == SyntaxKind::OfKeyword && lookAhead<bool>(CALLBACK(canFollowContextualOfKeyword))) {
                 declarations = createMissingList();
-            }
-            else {
+            } else {
                 auto savedDisallowIn = inDisallowInContext();
                 setDisallowInContext(inForStatementInitializer);
 
                 if (inForStatementInitializer) {
-                    declarations = *parseDelimitedList(ParsingContext::VariableDeclarations, [this]() { return parseVariableDeclaration(); });
+                    declarations = parseDelimitedList(ParsingContext::VariableDeclarations, [this]() { return parseVariableDeclaration(); });
                 } else {
-                    declarations = *parseDelimitedList(ParsingContext::VariableDeclarations, CALLBACK(parseVariableDeclarationAllowExclamation));
+                    declarations = parseDelimitedList(ParsingContext::VariableDeclarations, CALLBACK(parseVariableDeclarationAllowExclamation));
                 }
 
                 setDisallowInContext(savedDisallowIn);
@@ -7117,7 +7155,8 @@ namespace ts {
             return finishNode(factory.createVariableDeclarationList(declarations, flags), pos);
         }
 
-        shared<VariableStatement> parseVariableStatement(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers) {
+        shared<VariableStatement> parseVariableStatement(int pos, bool hasJSDoc, const sharedOpt<NodeArray> &decorators, const sharedOpt<NodeArray> &modifiers) {
+            ZoneScoped;
             auto declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false);
             parseSemicolon();
             auto node = factory.createVariableStatement(modifiers, declarationList);
@@ -7137,27 +7176,123 @@ namespace ts {
             return lookAhead<bool>(CALLBACK(nextTokenIsBindingIdentifierOrStartOfDestructuring));
         }
 
-        shared<FunctionDeclaration> parseFunctionDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers) {
+        shared<FunctionDeclaration> parseFunctionDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers) {
             auto savedAwaitContext = inAwaitContext();
 
             auto modifierFlags = modifiersToFlags(modifiers);
             parseExpected(SyntaxKind::FunctionKeyword);
             auto asteriskToken = parseOptionalToken<AsteriskToken>(SyntaxKind::AsteriskToken);
             // We don't parse the name here in await context, instead we will report a grammar error in the checker.
-            auto name = modifierFlags & (int)ModifierFlags::Default ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
+            auto name = modifierFlags & (int) ModifierFlags::Default ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
             auto isGenerator = asteriskToken ? SignatureFlags::Yield : SignatureFlags::None;
-            auto isAsync = modifierFlags & (int)ModifierFlags::Async ? SignatureFlags::Await : SignatureFlags::None;
+            auto isAsync = modifierFlags & (int) ModifierFlags::Async ? SignatureFlags::Await : SignatureFlags::None;
             auto typeParameters = parseTypeParameters();
-            if (modifierFlags & (int)ModifierFlags::Export) setAwaitContext(/*value*/ true);
-            auto parameters = parseParameters((int)isGenerator | (int)isAsync);
+            if (modifierFlags & (int) ModifierFlags::Export) setAwaitContext(/*value*/ true);
+            auto parameters = parseParameters((int) isGenerator | (int) isAsync);
             auto type = parseReturnType(SyntaxKind::ColonToken, /*isType*/ false);
-            auto body = parseFunctionBlockOrSemicolon((int)isGenerator | (int)isAsync, Diagnostics::or_expected);
+            auto body = parseFunctionBlockOrSemicolon((int) isGenerator | (int) isAsync, Diagnostics::or_expected);
             setAwaitContext(savedAwaitContext);
             auto node = factory.createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
 
+        shared<Statement> parseDeclaration() {
+            ZoneScoped;
+
+            // TODO: Can we hold onto the parsed decorators/modifiers and advance the scanner
+            //       if we can't reuse the declaration, so that we don't do this work twice?
+            //
+            // `parseListElement` attempted to get the reused node at this position,
+            // but the ambient context flag was not yet set, so the node appeared
+            // not reusable in that context.
+            auto a = lookAhead<sharedOpt<NodeArray>>([this]() {
+                parseDecorators();
+                return parseModifiers();
+            });
+            auto isAmbient = some(a, CALLBACK(isDeclareModifier));
+            if (isAmbient) {
+                auto node = tryReuseAmbientDeclaration();
+                if (node) {
+                    return node;
+                }
+            }
+
+            auto pos = getNodePos();
+            auto hasJSDoc = hasPrecedingJSDocComment();
+            auto decorators = parseDecorators();
+            auto modifiers = parseModifiers();
+            if (isAmbient) {
+                for (auto &m: modifiers->list) {
+                    m->flags |= (int) NodeFlags::Ambient;
+                }
+                return doInsideOfContext<shared<Statement>>((int) NodeFlags::Ambient, [this, &pos, &hasJSDoc, &decorators, &modifiers]() { return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); });
+            } else {
+                return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
+            }
+        }
+
+        sharedOpt<Statement> tryReuseAmbientDeclaration() {
+            ZoneScoped;
+            return doInsideOfContext<sharedOpt<Statement>>((int) NodeFlags::Ambient, [this]()->sharedOpt<Statement> {
+                auto node = currentNode((ParsingContext) parsingContext);
+                if (node) {
+                    return to<Statement>(consumeNode(node));
+                }
+                return nullptr;
+            });
+        }
+
+        shared<Statement> parseDeclarationWorker(int pos, bool hasJSDoc, sharedOpt<NodeArray> decorators, sharedOpt<NodeArray> modifiers) {
+            ZoneScoped;
+            switch (token()) {
+                case SyntaxKind::VarKeyword:
+                case SyntaxKind::LetKeyword:
+                case SyntaxKind::ConstKeyword:
+                    return parseVariableStatement(pos, hasJSDoc, decorators, modifiers);
+                case SyntaxKind::FunctionKeyword:
+                    return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::ClassKeyword:
+//                    return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::InterfaceKeyword:
+//                    return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::TypeKeyword:
+//                    return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::EnumKeyword:
+//                    return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::GlobalKeyword:
+//                case SyntaxKind::ModuleKeyword:
+//                case SyntaxKind::NamespaceKeyword:
+//                    return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::ImportKeyword:
+//                    return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                case SyntaxKind::ExportKeyword:
+//                    nextToken();
+//                    switch (token()) {
+//                        case SyntaxKind::DefaultKeyword:
+//                        case SyntaxKind::EqualsToken:
+//                            return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
+//                        case SyntaxKind::AsKeyword:
+//                            return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                        default:
+//                            return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
+//                    }
+//                default:
+//                    if (decorators || modifiers) {
+//                        // We reached this point because we encountered decorators and/or modifiers and assumed a declaration
+//                        // would follow. For recovery and error reporting purposes, return an incomplete declaration.
+//                        auto missing = createMissingNode<MissingDeclaration>(SyntaxKind::MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics::Declaration_expected);
+//                        setTextRangePos(missing, pos);
+//                        missing.decorators = decorators;
+//                        missing.modifiers = modifiers;
+//                        return missing;
+//                    }
+//                    return undefined!; // TODO: GH#18217
+            }
+            throw runtime_error("not implemented");
+        }
+
         shared<Statement> parseStatement() {
+            ZoneScoped;
             switch (token()) {
                 case SyntaxKind::SemicolonToken:
                     return parseEmptyStatement();
@@ -7202,34 +7337,35 @@ namespace ts {
 //                    return parseTryStatement();
 //                case SyntaxKind::DebuggerKeyword:
 //                    return parseDebuggerStatement();
-//                case SyntaxKind::AtToken:
-//                    return parseDeclaration();
-//                case SyntaxKind::AsyncKeyword:
-//                case SyntaxKind::InterfaceKeyword:
-//                case SyntaxKind::TypeKeyword:
-//                case SyntaxKind::ModuleKeyword:
-//                case SyntaxKind::NamespaceKeyword:
-//                case SyntaxKind::DeclareKeyword:
-//                case SyntaxKind::ConstKeyword:
-//                case SyntaxKind::EnumKeyword:
-//                case SyntaxKind::ExportKeyword:
-//                case SyntaxKind::ImportKeyword:
-//                case SyntaxKind::PrivateKeyword:
-//                case SyntaxKind::ProtectedKeyword:
-//                case SyntaxKind::PublicKeyword:
-//                case SyntaxKind::AbstractKeyword:
-//                case SyntaxKind::StaticKeyword:
-//                case SyntaxKind::ReadonlyKeyword:
-//                case SyntaxKind::GlobalKeyword:
-//                    if (isStartOfDeclaration()) {
-//                        return parseDeclaration();
-//                    }
-//                    break;
+                case SyntaxKind::AtToken:
+                    return parseDeclaration();
+                case SyntaxKind::AsyncKeyword:
+                case SyntaxKind::InterfaceKeyword:
+                case SyntaxKind::TypeKeyword:
+                case SyntaxKind::ModuleKeyword:
+                case SyntaxKind::NamespaceKeyword:
+                case SyntaxKind::DeclareKeyword:
+                case SyntaxKind::ConstKeyword:
+                case SyntaxKind::EnumKeyword:
+                case SyntaxKind::ExportKeyword:
+                case SyntaxKind::ImportKeyword:
+                case SyntaxKind::PrivateKeyword:
+                case SyntaxKind::ProtectedKeyword:
+                case SyntaxKind::PublicKeyword:
+                case SyntaxKind::AbstractKeyword:
+                case SyntaxKind::StaticKeyword:
+                case SyntaxKind::ReadonlyKeyword:
+                case SyntaxKind::GlobalKeyword:
+                    if (isStartOfDeclaration()) {
+                        return parseDeclaration();
+                    }
+                    break;
             }
             return to<Statement>(parseExpressionOrLabeledStatement());
         }
 
         shared<SourceFile> parseSourceFileWorker(ScriptTarget languageVersion, bool setParentNodes, ScriptKind scriptKind, function<void(shared<SourceFile>)> setExternalModuleIndicator) {
+            ZoneScoped;
             auto isDeclarationFile = isDeclarationFileName(fileName);
             if (isDeclarationFile) {
                 contextFlags |= (int) NodeFlags::Ambient;
@@ -7241,11 +7377,14 @@ namespace ts {
             nextToken();
 
             auto statements = parseList(ParsingContext::SourceElements, CALLBACK(parseStatement));
-//            Debug::asserts(token() == SyntaxKind::EndOfFileToken);
-//            auto endOfFileToken = addJSDocComment(parseTokenNode<EndOfFileToken>());
-//
-//            auto sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator);
-//
+//            auto statements = parseList(ParsingContext::SourceElements, [this]() {
+//                return this->parseStatement();
+//            });
+            Debug::asserts(token() == SyntaxKind::EndOfFileToken);
+            auto endOfFileToken = addJSDocComment(parseTokenNode<EndOfFileToken>());
+
+            auto sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator);
+
 //            // A member of ReadonlyArray<T> isn't assignable to a member of T[] (and prevents a direct cast) - but this is where we set up those members so they can be readonly in the future
 //            processCommentPragmas(sourceFile as {} as PragmaContext, sourceText);
 //            processPragmasIntoFields(sourceFile as {} as PragmaContext, reportPragmaDiagnostic);
@@ -7263,7 +7402,7 @@ namespace ts {
 //                fixupParentReferences(sourceFile);
 //            }
 //
-//            return sourceFile;
+            return sourceFile;
 //
 //            function reportPragmaDiagnostic(int pos, end: number, diagnostic: DiagnosticMessage) {
 //                parseDiagnostics.push(createDetachedDiagnostic(fileName, pos, end, diagnostic));
@@ -7271,98 +7410,12 @@ namespace ts {
         }
 //
 
-//        function parseDeclaration(): Statement {
-//            // TODO: Can we hold onto the parsed decorators/modifiers and advance the scanner
-//            //       if we can't reuse the declaration, so that we don't do this work twice?
-//            //
-//            // `parseListElement` attempted to get the reused node at this position,
-//            // but the ambient context flag was not yet set, so the node appeared
-//            // not reusable in that context.
-//            auto isAmbient = some(lookAhead(() => (parseDecorators(), parseModifiers())), isDeclareModifier);
-//            if (isAmbient) {
-//                auto node = tryReuseAmbientDeclaration();
-//                if (node) {
-//                    return node;
-//                }
-//            }
-//
-//            auto pos = getNodePos();
-//            auto hasJSDoc = hasPrecedingJSDocComment();
-//            auto decorators = parseDecorators();
-//            auto modifiers = parseModifiers();
-//            if (isAmbient) {
-//                for (const m of modifiers!) {
-//                    (m as Mutable<Node>).flags |= NodeFlags::Ambient;
-//                }
-//                return doInsideOfContext(NodeFlags::Ambient, () => parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers));
-//            }
-//            else {
-//                return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
-//            }
-//        }
-//
-//        function tryReuseAmbientDeclaration(): Statement | undefined {
-//            return doInsideOfContext(NodeFlags::Ambient, () => {
-//                auto node = currentNode(parsingContext);
-//                if (node) {
-//                    return consumeNode(node) as Statement;
-//                }
-//            });
-//        }
-//
-//        function parseDeclarationWorker(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): Statement {
-//            switch (token()) {
-//                case SyntaxKind::VarKeyword:
-//                case SyntaxKind::LetKeyword:
-//                case SyntaxKind::ConstKeyword:
-//                    return parseVariableStatement(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::FunctionKeyword:
-//                    return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::ClassKeyword:
-//                    return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::InterfaceKeyword:
-//                    return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::TypeKeyword:
-//                    return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::EnumKeyword:
-//                    return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::GlobalKeyword:
-//                case SyntaxKind::ModuleKeyword:
-//                case SyntaxKind::NamespaceKeyword:
-//                    return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::ImportKeyword:
-//                    return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                case SyntaxKind::ExportKeyword:
-//                    nextToken();
-//                    switch (token()) {
-//                        case SyntaxKind::DefaultKeyword:
-//                        case SyntaxKind::EqualsToken:
-//                            return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
-//                        case SyntaxKind::AsKeyword:
-//                            return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                        default:
-//                            return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
-//                    }
-//                default:
-//                    if (decorators || modifiers) {
-//                        // We reached this point because we encountered decorators and/or modifiers and assumed a declaration
-//                        // would follow. For recovery and error reporting purposes, return an incomplete declaration.
-//                        auto missing = createMissingNode<MissingDeclaration>(SyntaxKind::MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics::Declaration_expected);
-//                        setTextRangePos(missing, pos);
-//                        missing.decorators = decorators;
-//                        missing.modifiers = modifiers;
-//                        return missing;
-//                    }
-//                    return undefined!; // TODO: GH#18217
-//            }
-//        }
-//
 //        // DECLARATIONS
-//        function parseClassDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): ClassDeclaration {
+//        function parseClassDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): ClassDeclaration {
 //            return parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, SyntaxKind::ClassDeclaration) as ClassDeclaration;
 //        }
 //
-//        function parseInterfaceDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): InterfaceDeclaration {
+//        function parseInterfaceDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): InterfaceDeclaration {
 //            parseExpected(SyntaxKind::InterfaceKeyword);
 //            auto name = parseIdentifier();
 //            auto typeParameters = parseTypeParameters();
@@ -7372,7 +7425,7 @@ namespace ts {
 //            return withJSDoc(finishNode(node, pos), hasJSDoc);
 //        }
 //
-//        function parseTypeAliasDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): TypeAliasDeclaration {
+//        function parseTypeAliasDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): TypeAliasDeclaration {
 //            parseExpected(SyntaxKind::TypeKeyword);
 //            auto name = parseIdentifier();
 //            auto typeParameters = parseTypeParameters();
@@ -7395,7 +7448,7 @@ namespace ts {
 //            return withJSDoc(finishNode(factory.createEnumMember(name, initializer), pos), hasJSDoc);
 //        }
 //
-//        function parseEnumDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): EnumDeclaration {
+//        function parseEnumDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): EnumDeclaration {
 //            parseExpected(SyntaxKind::EnumKeyword);
 //            auto name = parseIdentifier();
 //            auto members;
@@ -7423,7 +7476,7 @@ namespace ts {
 //            return finishNode(factory.createModuleBlock(statements), pos);
 //        }
 //
-//        function parseModuleOrNamespaceDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers, flags: NodeFlags): ModuleDeclaration {
+//        function parseModuleOrNamespaceDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers, flags: NodeFlags): ModuleDeclaration {
 //            // If we are parsing a dotted namespace name, we want to
 //            // propagate the 'Namespace' flag across the names if set.
 //            auto namespaceFlag = flags & NodeFlags::Namespace;
@@ -7435,7 +7488,7 @@ namespace ts {
 //            return withJSDoc(finishNode(node, pos), hasJSDoc);
 //        }
 //
-//        function parseAmbientExternalModuleDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): ModuleDeclaration {
+//        function parseAmbientExternalModuleDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): ModuleDeclaration {
 //            auto flags: NodeFlags = 0;
 //            auto name;
 //            if (token() == SyntaxKind::GlobalKeyword) {
@@ -7458,7 +7511,7 @@ namespace ts {
 //            return withJSDoc(finishNode(node, pos), hasJSDoc);
 //        }
 //
-//        function parseModuleDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): ModuleDeclaration {
+//        function parseModuleDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): ModuleDeclaration {
 //            auto flags: NodeFlags = 0;
 //            if (token() == SyntaxKind::GlobalKeyword) {
 //                // global augmentation
@@ -7476,7 +7529,7 @@ namespace ts {
 //            return parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags);
 //        }
 //
-//        function parseNamespaceExportDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): NamespaceExportDeclaration {
+//        function parseNamespaceExportDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): NamespaceExportDeclaration {
 //            parseExpected(SyntaxKind::AsKeyword);
 //            parseExpected(SyntaxKind::NamespaceKeyword);
 //            auto name = parseIdentifier();
@@ -7488,7 +7541,7 @@ namespace ts {
 //            return withJSDoc(finishNode(node, pos), hasJSDoc);
 //        }
 //
-//        function parseImportDeclarationOrImportEqualsDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): ImportEqualsDeclaration | ImportDeclaration {
+//        function parseImportDeclarationOrImportEqualsDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): ImportEqualsDeclaration | ImportDeclaration {
 //            parseExpected(SyntaxKind::ImportKeyword);
 //
 //            auto afterImportPos = scanner.getStartPos();
@@ -7545,7 +7598,7 @@ namespace ts {
 //            return token() == SyntaxKind::CommaToken || token() == SyntaxKind::FromKeyword;
 //        }
 //
-//        function parseImportEqualsDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers, identifier: Identifier, isTypeOnly: boolean): ImportEqualsDeclaration {
+//        function parseImportEqualsDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers, identifier: Identifier, isTypeOnly: boolean): ImportEqualsDeclaration {
 //            parseExpected(SyntaxKind::EqualsToken);
 //            auto moduleReference = parseModuleReference();
 //            parseSemicolon();
@@ -7727,7 +7780,7 @@ namespace ts {
 //            return finishNode(factory.createNamespaceExport(parseIdentifierName()), pos);
 //        }
 //
-//        function parseExportDeclaration(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): ExportDeclaration {
+//        function parseExportDeclaration(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): ExportDeclaration {
 //            auto savedAwaitContext = inAwaitContext();
 //            setAwaitContext(/*value*/ true);
 //            auto exportClause: NamedExportBindings | undefined;
@@ -7761,7 +7814,7 @@ namespace ts {
 //            return withJSDoc(finishNode(node, pos), hasJSDoc);
 //        }
 //
-//        function parseExportAssignment(int pos, bool hasJSDoc, optional<NodeArray> decorators, optional<NodeArray> modifiers): ExportAssignment {
+//        function parseExportAssignment(int pos, bool hasJSDoc, sharedOpt<NodeArray>  decorators, sharedOpt<NodeArray>  modifiers): ExportAssignment {
 //            auto savedAwaitContext = inAwaitContext();
 //            setAwaitContext(/*value*/ true);
 //            auto isExportEquals: boolean | undefined;
@@ -8814,7 +8867,8 @@ namespace ts {
 //            }
 //        }
 
-        shared<SourceFile> parseSourceFile(string fileName, string sourceText, ScriptTarget languageVersion, bool setParentNodes, optional<ScriptKind> _scriptKind, optional<function<void(shared<SourceFile>)>> setExternalModuleIndicatorOverride) {
+        shared<SourceFile> parseSourceFile(const string &fileName, const string &sourceText, ScriptTarget languageVersion, bool setParentNodes, optional<ScriptKind> _scriptKind, optional<function<void(shared<SourceFile>)>> setExternalModuleIndicatorOverride) {
+            ZoneScoped;
             auto scriptKind = ensureScriptKind(fileName, _scriptKind);
 
             //            if (scriptKind == ScriptKind.JSON) {
@@ -9428,8 +9482,8 @@ namespace ts {
 //                Debug::asserts((oldText.length - textChangeRange.span.length + textChangeRange.newLength) == newText.length);
 //
 //                if (aggressiveChecks || Debug.shouldAssert(AssertionLevel.VeryAggressive)) {
-//                    auto oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
-//                    auto newTextPrefix = newText.substr(0, textChangeRange.span.start);
+//                    auto oldTextPrefix = substr(oldText, 0, textChangeRange.span.start);
+//                    auto newTextPrefix = substr(newText, 0, textChangeRange.span.start);
 //                    Debug::asserts(oldTextPrefix == newTextPrefix);
 //
 //                    auto oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length);
@@ -9801,10 +9855,16 @@ namespace ts {
 //        return argMap;
 //    }
 
-    shared<SourceFile> createSourceFile(string fileName, string sourceText, variant<ScriptTarget, CreateSourceFileOptions> languageVersionOrOptions, bool setParentNodes = false, optional<ScriptKind> scriptKind = {}) {
+    inline shared<SourceFile> createSourceFile(
+            string fileName,
+            string sourceText,
+            variant<ScriptTarget, CreateSourceFileOptions> languageVersionOrOptions,
+            bool setParentNodes = false,
+            optional<ScriptKind> scriptKind = {}
+    ) {
 //        tracing?.push(tracing.Phase.Parse, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true);
 //        performance.mark("beforeParse");
-        shared_ptr<SourceFile> result = make_shared<SourceFile>();
+        shared<SourceFile> result;
         optional<function<void(shared<SourceFile>)>> overrideSetExternalModuleIndicator;
         optional<ModuleKind> format;
 
diff --git a/src/path.cpp b/src/path.cpp
index f32ff33..c0ad92d 100644
--- a/src/path.cpp
+++ b/src/path.cpp
@@ -11,7 +11,7 @@ namespace ts {
         return path.size() > extension.size() && endsWith(path, extension);
     }
 
-    bool fileExtensionIsOneOf(const string &path, vector<string> extensions) {
+    bool fileExtensionIsOneOf(const string &path, const vector<string> &extensions) {
         for (auto &extension: extensions) {
             if (fileExtensionIs(path, extension)) {
                 return true;
@@ -21,7 +21,7 @@ namespace ts {
         return false;
     }
 
-    bool fileExtensionIsOneOf(const string &path, vector<const char *> extensions) {
+    bool fileExtensionIsOneOf(const string &path, const vector<const char *> &extensions) {
         return fileExtensionIsOneOf(path, charToStringVector(extensions));
     }
 
@@ -33,12 +33,12 @@ namespace ts {
     }
 
     //// Path Parsing
-    bool isVolumeCharacter(CharCode charCode) {
+    bool isVolumeCharacter(const CharCode &charCode) {
         return (charCode.code >= CharacterCodes::a && charCode.code <= CharacterCodes::z) ||
                (charCode.code >= CharacterCodes::A && charCode.code <= CharacterCodes::Z);
     }
 
-    int getFileUrlVolumeSeparatorEnd(string url, int start) {
+    int getFileUrlVolumeSeparatorEnd(const string &url, int start) {
         auto ch0 = charCodeAt(url, start);
         if (ch0.code == CharacterCodes::colon) return start + 1;
         if (ch0.code == CharacterCodes::percent && charCodeAt(url, start + 1).code == CharacterCodes::_3) {
@@ -52,7 +52,7 @@ namespace ts {
      * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
      * If the root is part of a URL, the twos-complement of the root length is returned.
      */
-    int getEncodedRootLength(string path) {
+    int getEncodedRootLength(const string &path) {
         if (path.empty()) return 0;
         auto ch0 = charCodeAt(path, 0);
 
@@ -141,7 +141,7 @@ namespace ts {
     /**
      * Determines whether a charCode corresponds to `/` or `\`.
      */
-    bool isAnyDirectorySeparator(CharCode charCode) {
+    bool isAnyDirectorySeparator(const CharCode &charCode) {
         return charCode.code == CharacterCodes::slash || charCode.code == CharacterCodes::backslash;
     }
 
@@ -149,7 +149,7 @@ namespace ts {
         return path.size() > 0 && isAnyDirectorySeparator(charCodeAt(path, path.size() - 1));
     }
 
-    string ensureTrailingDirectorySeparator(string path) {
+    string ensureTrailingDirectorySeparator(const string &path) {
         if (! hasTrailingDirectorySeparator(path)) {
             return path + directorySeparator;
         }
@@ -175,21 +175,21 @@ namespace ts {
      * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
      * ```
      */
-    string combinePaths(string path, vector<string> paths) {
+    string combinePaths(string path, const vector<string> &paths) {
         if (! path.empty()) path = normalizeSlashes(path);
         for (auto &relativePath: paths) {
             if (relativePath.empty()) continue;
-            relativePath = normalizeSlashes(relativePath);
-            if (path.empty() || getRootLength(relativePath) != 0) {
-                path = relativePath;
+            auto p = normalizeSlashes(relativePath);
+            if (path.empty() || getRootLength(p) != 0) {
+                path = p;
             } else {
-                path = ensureTrailingDirectorySeparator(path) + relativePath;
+                path = ensureTrailingDirectorySeparator(path) + p;
             }
         }
         return path;
     }
 
-    vector<string> pathComponents(string path, int rootLength) {
+    vector<string> pathComponents(const string &path, int rootLength) {
         auto root = path.substr(0, rootLength);
         auto rest = split(path.substr(rootLength), directorySeparator);
         if (rest.size() && ! lastOrUndefined(rest)) rest.pop_back();
@@ -227,9 +227,9 @@ namespace ts {
      * getPathComponents("file:///") === ["file:///"]
      * getPathComponents("file://") === ["file://"]
      */
-    vector<string> getPathComponents(string path, const string &currentDirectory) {
-        path = combinePaths(currentDirectory, {path});
-        return pathComponents(path, getRootLength(path));
+    vector<string> getPathComponents(const string &path, const string &currentDirectory) {
+        auto p = combinePaths(currentDirectory, {path});
+        return pathComponents(p, getRootLength(p));
     }
 
     /**
@@ -275,21 +275,23 @@ namespace ts {
 
     string normalizePath(string &_path) {
         string path = normalizeSlashes(_path);
+        //todo: rework that to make it faster
+        return path;
         // Most paths don't require normalization
-        if (! regex_search(path, relativePathSegmentRegExp)) {
-            return path;
-        }
-        // Some paths only require cleanup of `/./` or leading `./`
-        auto simplified = replaceLeading(replaceAll(path, "/./", "/"), "./", "");
-        if (simplified != path) {
-            path = simplified;
-            if (! regex_search(path, relativePathSegmentRegExp)) {
-                return path;
-            }
-        }
-        // Other paths require full normalization
-        auto normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
-        if (! normalized.empty() && hasTrailingDirectorySeparator(path)) return ensureTrailingDirectorySeparator(normalized);
-        return normalized;
+//        if (! regex_search(path, relativePathSegmentRegExp)) {
+//            return path;
+//        }
+//        // Some paths only require cleanup of `/./` or leading `./`
+//        auto simplified = replaceLeading(replaceAll(path, "/./", "/"), "./", "");
+//        if (simplified != path) {
+//            path = simplified;
+//            if (! regex_search(path, relativePathSegmentRegExp)) {
+//                return path;
+//            }
+//        }
+//        // Other paths require full normalization
+//        auto normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
+//        if (! normalized.empty() && hasTrailingDirectorySeparator(path)) return ensureTrailingDirectorySeparator(normalized);
+//        return normalized;
     }
 }
diff --git a/src/path.h b/src/path.h
index 0f14627..4b7c834 100644
--- a/src/path.h
+++ b/src/path.h
@@ -19,9 +19,9 @@ namespace ts {
 
     bool fileExtensionIs(const string &path, const string &extension);
 
-    bool fileExtensionIsOneOf(const string &path, vector<string> extensions);
+    bool fileExtensionIsOneOf(const string &path, const vector<string> &extensions);
 
-    bool fileExtensionIsOneOf(const string &path, vector<const char *> extensions);
+    bool fileExtensionIsOneOf(const string &path, const vector<const char *> &extensions);
 
     /**
      * Normalize path separators, converting `\` into `/`.
@@ -29,15 +29,15 @@ namespace ts {
     string normalizeSlashes(const string &path);
 
     //// Path Parsing
-    bool isVolumeCharacter(CharCode charCode);
+    bool isVolumeCharacter(const CharCode &charCode);
 
-    int getFileUrlVolumeSeparatorEnd(string url, int start);
+    int getFileUrlVolumeSeparatorEnd(const string &url, int start);
 
     /**
      * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
      * If the root is part of a URL, the twos-complement of the root length is returned.
      */
-    int getEncodedRootLength(string path);
+    int getEncodedRootLength(const string &path);
 
     /**
      * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
@@ -69,11 +69,11 @@ namespace ts {
     /**
      * Determines whether a charCode corresponds to `/` or `\`.
      */
-    bool isAnyDirectorySeparator(CharCode charCode);
+    bool isAnyDirectorySeparator(const CharCode &charCode);
 
     bool hasTrailingDirectorySeparator(const string &path);
 
-    string ensureTrailingDirectorySeparator(string path);
+    string ensureTrailingDirectorySeparator(const string &path);
 
     /**
      * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified.
@@ -93,9 +93,9 @@ namespace ts {
      * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
      * ```
      */
-    string combinePaths(string path, vector<string> paths);
+    string combinePaths(string path, const vector<string> &paths);
 
-    vector<string> pathComponents(string path, int rootLength);
+    vector<string> pathComponents(const string &path, int rootLength);
 
     /**
      * Parse a path into an array containing a root component (at index 0) and zero or more path
@@ -127,7 +127,7 @@ namespace ts {
      * getPathComponents("file:///") === ["file:///"]
      * getPathComponents("file://") === ["file://"]
      */
-    vector<string> getPathComponents(string path, const string &currentDirectory = "");
+    vector<string> getPathComponents(const string &path, const string &currentDirectory = "");
 
     /**
      * Formats a parsed path consisting of a root component (at index 0) and zero or more path
diff --git a/src/scanner.cpp b/src/scanner.cpp
index d8301eb..6b992e1 100644
--- a/src/scanner.cpp
+++ b/src/scanner.cpp
@@ -19,7 +19,7 @@ namespace ts {
         return false;
     }
 
-    bool isWhiteSpaceSingleLine(CharCode ch) {
+    bool isWhiteSpaceSingleLine(const CharCode &ch) {
         // Note: nextLine is in the Zs space, and should be considered to be a whitespace.
         // It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript.
         return ch.code == CharacterCodes::space ||
@@ -43,25 +43,25 @@ namespace ts {
         auto start = pos;
         while (true) {
             if (pos >= end) {
-                result += substr(text, start, pos);
+                result += substring(text, start, pos);
                 tokenFlags |= TokenFlags::Unterminated;
 //            error(Diagnostics::Unterminated_string_literal);
                 break;
             }
             auto ch = charCodeAt(text, pos);
             if (ch.code == quote.code) {
-                result += substr(text, start, pos);
+                result += substring(text, start, pos);
                 pos++;
                 break;
             }
             if (ch.code == CharacterCodes::backslash && !jsxAttributeString) {
-                result += substr(text, start, pos);
+                result += substring(text, start, pos);
                 result += scanEscapeSequence();
                 start = pos;
                 continue;
             }
             if (isLineBreak(ch) && !jsxAttributeString) {
-                result += substr(text, start, pos);
+                result += substring(text, start, pos);
                 tokenFlags |= TokenFlags::Unterminated;
 //            error(Diagnostics::Unterminated_string_literal);
                 break;
@@ -71,11 +71,11 @@ namespace ts {
         return result;
     }
 
-    bool isDigit(CharCode ch) {
+    bool isDigit(const CharCode &ch) {
         return ch.code >= CharacterCodes::_0 && ch.code <= CharacterCodes::_9;
     }
 
-    bool isHexDigit(CharCode ch) {
+    bool isHexDigit(const CharCode &ch) {
         return isDigit(ch) || (ch.code >= CharacterCodes::A && ch.code <= CharacterCodes::F) ||
                (ch.code >= CharacterCodes::a && ch.code <= CharacterCodes::f);
     }
@@ -113,7 +113,7 @@ namespace ts {
                 break;
             }
             found++;
-            result.append(substr(text, pos, ch.length));
+            result.append(substring(text, pos, ch.length));
             pos++;
             isPreviousTokenSeparator = false;
         }
@@ -125,7 +125,7 @@ namespace ts {
         return result;
     }
 
-    bool isCodePoint(CharCode ch) {
+    bool isCodePoint(const CharCode &ch) {
         return ch.code <= 0x10FFFF;
     }
 
@@ -193,7 +193,7 @@ namespace ts {
                 if (isTaggedTemplate && pos < end && isDigit(charCodeAt(text, pos))) {
                     pos++;
                     tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                    return substr(text, start, pos);
+                    return substring(text, start, pos);
                 }
                 return "\0";
             case CharacterCodes::b:
@@ -220,7 +220,7 @@ namespace ts {
                             charCodeAt(text, escapePos).code != CharacterCodes::openBrace) {
                             pos = escapePos;
                             tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                            return substr(text, start, pos);
+                            return substring(text, start, pos);
                         }
                     }
                 }
@@ -231,7 +231,7 @@ namespace ts {
                     // '\u{'
                     if (isTaggedTemplate && !isHexDigit(charCodeAt(text, pos))) {
                         tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                        return substr(text, start, pos);
+                        return substring(text, start, pos);
                     }
 
                     if (isTaggedTemplate) {
@@ -244,13 +244,13 @@ namespace ts {
                             // '\u{Not Code Point' or '\u{CodePoint'
                             if (charCodeAt(text, pos).code != CharacterCodes::closeBrace) {
                                 tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                                return substr(text, start, pos);
+                                return substring(text, start, pos);
                             } else {
                                 pos = savePos;
                             }
                         } catch (invalid_argument &error) {
                             tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                            return substr(text, start, pos);
+                            return substring(text, start, pos);
                         }
                     }
                     tokenFlags |= TokenFlags::ExtendedUnicodeEscape;
@@ -265,11 +265,11 @@ namespace ts {
                 if (isTaggedTemplate) {
                     if (!isHexDigit(charCodeAt(text, pos))) {
                         tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                        return substr(text, start, pos);
+                        return substring(text, start, pos);
                     } else if (!isHexDigit(charCodeAt(text, pos + 1))) {
                         pos++;
                         tokenFlags |= TokenFlags::ContainsInvalidEscape;
-                        return substr(text, start, pos);
+                        return substring(text, start, pos);
                     }
                 }
                 // '\xDD'
@@ -301,7 +301,7 @@ namespace ts {
 
         while (true) {
             if (pos >= end) {
-                contents += substr(text, start, pos);
+                contents += substring(text, start, pos);
                 tokenFlags |= TokenFlags::Unterminated;
 //            error(Diagnostics::Unterminated_template_literal);
                 resultingToken = startedWithBacktick ? SyntaxKind::NoSubstitutionTemplateLiteral : SyntaxKind::TemplateTail;
@@ -312,7 +312,7 @@ namespace ts {
 
             // '`'
             if (currChar.code == CharacterCodes::backtick) {
-                contents += substr(text, start, pos);
+                contents += substring(text, start, pos);
                 pos++;
                 resultingToken = startedWithBacktick ? SyntaxKind::NoSubstitutionTemplateLiteral : SyntaxKind::TemplateTail;
                 break;
@@ -320,7 +320,7 @@ namespace ts {
 
             // '${'
             if (currChar.code == CharacterCodes::$ && pos + 1 < end && charCodeAt(text, pos + 1).code == CharacterCodes::openBrace) {
-                contents += substr(text, start, pos);
+                contents += substring(text, start, pos);
                 pos += 2;
                 resultingToken = startedWithBacktick ? SyntaxKind::TemplateHead : SyntaxKind::TemplateMiddle;
                 break;
@@ -328,7 +328,7 @@ namespace ts {
 
             // Escape character
             if (currChar.code == CharacterCodes::backslash) {
-                contents += substr(text, start, pos);
+                contents += substring(text, start, pos);
                 contents += scanEscapeSequence(isTaggedTemplate);
                 start = pos;
                 continue;
@@ -337,7 +337,7 @@ namespace ts {
             // Speculated ECMAScript 6 Spec 11.8.6.1:
             // <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for Template Values
             if (currChar.code == CharacterCodes::carriageReturn) {
-                contents += substr(text, start, pos);
+                contents += substring(text, start, pos);
                 pos++;
 
                 if (pos < end && charCodeAt(text, pos).code == CharacterCodes::lineFeed) {
@@ -370,7 +370,7 @@ namespace ts {
                 if (allowSeparator) {
                     allowSeparator = false;
                     isPreviousTokenSeparator = true;
-                    result += substr(text, start, pos);
+                    result += substring(text, start, pos);
                 } else if (isPreviousTokenSeparator) {
 //                error(Diagnostics::Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
                 } else {
@@ -391,7 +391,7 @@ namespace ts {
         if (charCodeAt(text, pos - 1).code == CharacterCodes::_) {
 //        error(Diagnostics::Numeric_separators_are_not_allowed_here, pos - 1, 1);
         }
-        return result + substr(text, start, pos);
+        return result + substring(text, start, pos);
     }
 
     map<string, SyntaxKind> textToKeyword{
@@ -588,20 +588,36 @@ namespace ts {
                lookupInUnicodeMap(code, unicodeES3IdentifierStart);
     }
 
-    bool isUnicodeIdentifierPart(CharCode ch, ScriptTarget languageVersion) {
+    bool isUnicodeIdentifierPart(const CharCode &ch, ScriptTarget languageVersion) {
         return languageVersion >= ScriptTarget::ES2015 ?
                lookupInUnicodeMap(ch, unicodeESNextIdentifierPart) :
                languageVersion == ScriptTarget::ES5 ? lookupInUnicodeMap(ch, unicodeES5IdentifierPart) :
                lookupInUnicodeMap(ch, unicodeES3IdentifierPart);
     }
 
-    bool isIdentifierStart(CharCode ch, ScriptTarget languageVersion) {
+    bool isIdentifierStart(const CharCode &ch, ScriptTarget languageVersion) {
         return (ch.code >= CharacterCodes::A && ch.code <= CharacterCodes::Z) || (ch.code >= CharacterCodes::a && ch.code <= CharacterCodes::z) ||
                ch.code == CharacterCodes::$ || ch.code == CharacterCodes::_ ||
                (ch.code > CharacterCodes::maxAsciiCharacter && isUnicodeIdentifierStart(ch, languageVersion));
     }
 
-    bool isIdentifierPart(CharCode ch, ScriptTarget languageVersion, LanguageVariant identifierVariant = LanguageVariant::Standard) {
+    /* @internal */
+    bool isIdentifierText(string name, ScriptTarget languageVersion, LanguageVariant identifierVariant) {
+        auto ch = charCodeAt(name, 0);
+        if (!isIdentifierStart(ch, languageVersion)) {
+            return false;
+        }
+
+        for (int i = ch.length; i < name.size(); i += ch.length) {
+            if (!isIdentifierPart(ch = charCodeAt(name, i), languageVersion, identifierVariant)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool isIdentifierPart(const CharCode &ch, ScriptTarget languageVersion, LanguageVariant identifierVariant) {
         return (ch.code >= CharacterCodes::A && ch.code <= CharacterCodes::Z) || (ch.code >= CharacterCodes::a && ch.code <= CharacterCodes::z) ||
                (ch.code >= CharacterCodes::_0 && ch.code <= CharacterCodes::_9) || ch.code == CharacterCodes::$ || ch.code == CharacterCodes::_ ||
                // "-" and ":" are valid in JSX Identifiers
@@ -619,12 +635,13 @@ namespace ts {
         return pos;
     }
 
-    bool isWhiteSpaceLike(CharCode ch) {
+    bool isWhiteSpaceLike(const CharCode &ch) {
         return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
     }
 
 /* @internal */
     int ts::skipTrivia(string &text, int pos, optional<bool> stopAfterLineBreak, optional<bool> stopAtComments, optional<bool> inJSDoc) {
+        ZoneScoped;
         if (positionIsSynthesized(pos)) {
             return pos;
         }
@@ -763,7 +780,7 @@ namespace ts {
                     break;
                 }
                 tokenFlags |= TokenFlags::UnicodeEscape;
-                result += substr(text, start, pos);
+                result += substring(text, start, pos);
                 result += fromCharCode(ch.code);
                 // Valid Unicode escape is always six characters
                 pos += 6;
@@ -772,7 +789,7 @@ namespace ts {
                 break;
             }
         }
-        result += substr(text, start, pos);
+        result += substring(text, start, pos);
         return result;
     }
 
@@ -809,9 +826,9 @@ namespace ts {
             // not a bigint, so can convert to number in simplified form
             // Number() may not support 0b or 0o, so use parseInt() instead
             auto numericValue = tokenFlags & TokenFlags::BinarySpecifier
-                                ? stoi(substr(tokenValue, 2), 0, 2) // skip "0b"
+                                ? stoi(substring(tokenValue, 2), 0, 2) // skip "0b"
                                 : tokenFlags & TokenFlags::OctalSpecifier
-                                  ? stoi(substr(tokenValue, 2), 0, 8) // skip "0o"
+                                  ? stoi(substring(tokenValue, 2), 0, 8) // skip "0o"
                                   : stoi(tokenValue);
             tokenValue = "" + std::to_string(numericValue);
             return SyntaxKind::NumericLiteral;
@@ -867,8 +884,8 @@ namespace ts {
                 }
             }
             // Do not include a trailing namespace separator in the token, since this is against the spec.
-            if (substr(tokenValue, -1) == ":") {
-                tokenValue = substr(tokenValue, 0, -1);
+            if (substring(tokenValue, -1) == ":") {
+                tokenValue = substring(tokenValue, 0, -1);
                 pos--;
             }
             return getIdentifierToken();
@@ -942,12 +959,12 @@ namespace ts {
             pos++;
         }
 
-        tokenValue = substr(text, startPos, pos);
+        tokenValue = substring(text, startPos, pos);
 
         return firstNonWhitespace == -1 ? SyntaxKind::JsxTextAllWhiteSpaces : SyntaxKind::JsxText;
     }
 
-    bool isLineBreak(CharCode ch) {
+    bool isLineBreak(const CharCode &ch) {
         // ES5 7.3:
         // The ECMAScript line terminator characters are listed in Table 3.
         //     Table 3: Line Terminator Characters
@@ -1002,7 +1019,7 @@ namespace ts {
             if (!finalFragment.size()) {
 //            error(Diagnostics::Digit_expected);
             } else {
-                scientificFragment = substr(text, end, preNumericPart) + finalFragment;
+                scientificFragment = substring(text, end, preNumericPart) + finalFragment;
                 scientificFragmentSet = true;
                 end = pos;
             }
@@ -1017,7 +1034,7 @@ namespace ts {
                 result += scientificFragment;
             }
         } else {
-            result = substr(text, start, end); // No need to use all the fragments; no _ removal needed
+            result = substring(text, start, end); // No need to use all the fragments; no _ removal needed
         }
 
         if (decimalFragmentSet || tokenFlags & TokenFlags::Scientific) {
@@ -1091,7 +1108,7 @@ namespace ts {
         if (isIdentifierStart(ch, languageVersion)) {
             pos += ch.length;
             while (pos < end && isIdentifierPart(ch = charCodeAt(text, pos), languageVersion)) pos += ch.length;
-            tokenValue = substr(text, tokenPos, pos);
+            tokenValue = substring(text, tokenPos, pos);
             if (ch.code == CharacterCodes::backslash) {
                 tokenValue += scanIdentifierParts();
             }
@@ -1276,7 +1293,7 @@ namespace ts {
 
                         commentDirectives = appendIfCommentDirective(
                                 commentDirectives,
-                                substr(text, tokenPos, pos),
+                                substring(text, tokenPos, pos),
                                 commentDirectiveRegExSingleLine,
                                 tokenPos
                         );
@@ -1313,7 +1330,7 @@ namespace ts {
                             }
                         }
 
-                        commentDirectives = appendIfCommentDirective(commentDirectives, substr(text, lastLineStart, pos),
+                        commentDirectives = appendIfCommentDirective(commentDirectives, substring(text, lastLineStart, pos),
                                                                      commentDirectiveRegExMultiLine, lastLineStart);
 
                         if (!commentClosed) {
@@ -1576,7 +1593,7 @@ namespace ts {
         return SyntaxKind::EndOfFileToken;
     }
 
-    bool Scanner::isOctalDigit(CharCode ch) {
+    bool Scanner::isOctalDigit(const CharCode &ch) {
         return ch.code >= CharacterCodes::_0 && ch.code <= CharacterCodes::_7;
     }
 
@@ -1585,40 +1602,7 @@ namespace ts {
         while (isOctalDigit(charCodeAt(text, pos))) {
             pos++;
         }
-        return stoi(substr(text, start, pos));
-    }
-
-    template<typename T>
-    T Scanner::lookAhead(function<T()> callback) {
-        return speculationHelper<T>(callback, /*isLookahead*/ true);
-    }
-
-    template<typename T>
-    T Scanner::tryScan(function<T()> callback) {
-        return speculationHelper<T>(callback, /*isLookahead*/ false);
-    }
-
-    template<typename T>
-    T Scanner::speculationHelper(function<T()> callback, bool isLookahead) {
-        auto savePos = pos;
-        auto saveStartPos = startPos;
-        auto saveTokenPos = tokenPos;
-        auto saveToken = token;
-        auto saveTokenValue = tokenValue;
-        auto saveTokenFlags = tokenFlags;
-        auto result = callback();
-
-        // If our callback returned something 'falsy' or we're just looking ahead,
-        // then unconditionally restore us to where we were.
-        if (!result || isLookahead) {
-            pos = savePos;
-            startPos = saveStartPos;
-            tokenPos = saveTokenPos;
-            token = saveToken;
-            tokenValue = saveTokenValue;
-            tokenFlags = saveTokenFlags;
-        }
-        return result;;
+        return stoi(substring(text, start, pos));
     }
 
     SyntaxKind Scanner::reScanJsxToken(bool allowMultilineJsxText) {
@@ -1693,7 +1677,7 @@ namespace ts {
                 p++;
             }
             pos = p;
-            tokenValue = substr(text, tokenPos, pos);
+            tokenValue = substring(text, tokenPos, pos);
             token = SyntaxKind::RegularExpressionLiteral;
         }
         return token;
diff --git a/src/scanner.h b/src/scanner.h
index 92e3870..ac28d56 100644
--- a/src/scanner.h
+++ b/src/scanner.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Tracy.hpp"
 #include <string>
 #include <regex>
 #include <any>
@@ -356,19 +357,19 @@ namespace ts {
         return token == SyntaxKind::GreaterThanToken || tokenIsIdentifierOrKeyword(token);
     }
 
-    bool isUnicodeIdentifierPart(CharCode code, optional<ScriptTarget> languageVersion = {});
+    bool isUnicodeIdentifierPart(const CharCode &code, ScriptTarget languageVersion = ScriptTarget::Latest);
 
-    bool isIdentifierPart(CharCode ch, optional<ScriptTarget> languageVersion = {}, optional<LanguageVariant> identifierVariant = {});
+    bool isIdentifierPart(const CharCode &ch, ScriptTarget languageVersion = ScriptTarget::Latest, LanguageVariant identifierVariant = LanguageVariant::Standard);
 
     /* @internal */
-    bool isUnicodeIdentifierStart(CharCode code, optional<ScriptTarget> languageVersion = {});
+    bool isUnicodeIdentifierStart(CharCode code, ScriptTarget languageVersion = ScriptTarget::Latest);
 
-    bool isIdentifierStart(CharCode ch, optional<ScriptTarget> languageVersion = {});
+    bool isIdentifierStart(const CharCode &ch, ScriptTarget languageVersion = ScriptTarget::Latest);
     
     /* @internal */
-    bool isIdentifierText(string name, optional<ScriptTarget> languageVersion = {}, optional<LanguageVariant> identifierVariant = {});
+    bool isIdentifierText(string name, ScriptTarget languageVersion = ScriptTarget::Latest, LanguageVariant identifierVariant = LanguageVariant::Standard);
 
-    bool isLineBreak(CharCode ch);
+    bool isLineBreak(const CharCode &ch);
 
     class Scanner {
     public:
@@ -477,13 +478,40 @@ namespace ts {
         }
 
         template<typename T>
-        T lookAhead(function<T()> callback);
+        T lookAhead(const function<T()> &callback) {
+            ZoneScoped;
+            return speculationHelper<T>(callback, /*isLookahead*/ true);
+        }
 
         template<typename T>
-        T tryScan(function<T()> callback);
+        T tryScan(const function<T()> &callback) {
+            ZoneScoped;
+            return speculationHelper<T>(callback, /*isLookahead*/ false);
+        }
 
         template<typename T>
-        T speculationHelper(function<T()> callback, bool isLookahead);
+        T speculationHelper(const function<T()> &callback, bool isLookahead) {
+            ZoneScoped;
+            auto savePos = pos;
+            auto saveStartPos = startPos;
+            auto saveTokenPos = tokenPos;
+            auto saveToken = token;
+            auto saveTokenValue = tokenValue;
+            auto saveTokenFlags = tokenFlags;
+            auto result = callback();
+
+            // If our callback returned something 'falsy' or we're just looking ahead,
+            // then unconditionally restore us to where we were.
+            if (!(bool)result || isLookahead) {
+                pos = savePos;
+                startPos = saveStartPos;
+                tokenPos = saveTokenPos;
+                token = saveToken;
+                tokenValue = saveTokenValue;
+                tokenFlags = saveTokenFlags;
+            }
+            return result;;
+        }
 
         bool hasPrecedingLineBreak() {
             return (tokenFlags & TokenFlags::PrecedingLineBreak) != 0;
@@ -518,7 +546,7 @@ namespace ts {
         SyntaxKind reScanJsxToken(bool allowMultilineJsxText = false);
 
         string getTokenText() {
-            return text.substr(tokenPos, pos);
+            return substring(text, tokenPos, pos);
         }
 
         SyntaxKind reScanLessThanToken() {
@@ -591,7 +619,7 @@ namespace ts {
 
         string scanString(bool jsxAttributeString = false);
 
-        bool isOctalDigit(CharCode code);
+        bool isOctalDigit(const CharCode &code);
 
         int error(DiagnosticMessage message, int errPos = -1, int length = -1);
 
diff --git a/src/tests/CmakeLists.txt b/src/tests/CmakeLists.txt
index 6abb70c..529dd19 100644
--- a/src/tests/CmakeLists.txt
+++ b/src/tests/CmakeLists.txt
@@ -61,7 +61,10 @@ foreach(file ${TESTS})
     get_filename_component(name ${file} NAME_WE)
     MESSAGE("Test found typescript_${name}.")
     add_executable(typescript_${name} ${file})
-#    target_link_libraries(typescript_${name} gtest_main)
+
+#    target_link_libraries(typescript_${name} PUBLIC Tracy::TracyClient)
+
+    #    target_link_libraries(typescript_${name} gtest_main)
     target_link_libraries(typescript_${name} gtest gtest_main typescript)
 #    target_link_libraries(typescript_${name} PRIVATE Catch2::Catch2WithMain)
 #    target_link_libraries(typescript_${name} PRIVATE typescript)
diff --git a/src/tests/test_core.cpp b/src/tests/test_core.cpp
index 13279bd..33aba8d 100644
--- a/src/tests/test_core.cpp
+++ b/src/tests/test_core.cpp
@@ -345,10 +345,32 @@ TEST(core, startsWith) {
     EXPECT_EQ(startsWith("this/is/a/path", "this/"), true);
 }
 
-TEST(core, substrNegative) {
+TEST(core, substr) {
     string a = "abc";
+    EXPECT_EQ(substr(a, 0), "abc");
+    EXPECT_EQ(substr(a, 1), "bc");
+    EXPECT_EQ(substr(a, 0, 2), "ab");
+    EXPECT_EQ(substr(a, 1, 0), "");
+    EXPECT_EQ(substr(a, 1, 1), "b");
+    EXPECT_EQ(substr(a, 1, 2), "bc");
+    EXPECT_EQ(substr(a, 1, 3), "bc");
+    EXPECT_EQ(substr(a, 1, 5), "bc");
     EXPECT_EQ(substr(a, -1), "c");
-    EXPECT_EQ(substr(a, 0, -1), "ab");
+    EXPECT_EQ(substr(a, 0, -1), "");
+}
+
+TEST(core, substring) {
+    string a = "abc";
+    EXPECT_EQ(substring(a, 0), "abc");
+    EXPECT_EQ(substring(a, 1), "bc");
+    EXPECT_EQ(substring(a, 0, 2), "ab");
+    EXPECT_EQ(substring(a, 1, 2), "b");
+    EXPECT_EQ(substring(a, 1, 3), "bc");
+    EXPECT_EQ(substring(a, 1, 5), "bc");
+    EXPECT_EQ(substring(a, -1), "abc");
+    EXPECT_EQ(substring(a, 0, 0), "");
+    EXPECT_EQ(substring(a, 0, -1), "");
+    EXPECT_EQ(substring(a, 0, -2), "");
 }
 
 TEST(core, regex) {
@@ -371,6 +393,31 @@ T executeFn(function<T()> callback) {
     return callback();
 }
 
+class TestExec {
+public:
+    bool callback() {
+        return true;
+    }
+
+    bool executeFn(function<bool()> callback) {
+        return callback();
+    }
+
+    bool doIt() {
+        return executeFn([this]{ return callback(); });
+    }
+};
+
+TEST(core, stringView) {
+    std::string_view s = "abcdefgh";
+
+}
+
 TEST(core, passFn) {
-    auto a = executeFn<bool>(test);
-}
\ No newline at end of file
+    TestExec test;
+
+    test.doIt();
+
+//
+//    auto a = executeFn<bool>([]{ return test(); });
+}
diff --git a/src/tests/test_parser.cpp b/src/tests/test_parser.cpp
index d1f1ef4..9c4c9ce 100644
--- a/src/tests/test_parser.cpp
+++ b/src/tests/test_parser.cpp
@@ -1,11 +1,33 @@
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include "../parser2.h"
 
 using namespace ts;
 
-TEST(parser, basisc) {
-//    Parser parser("test.ts", "const i = 123;");
-//
-//    parser.parse();
+TEST(parser, bench) {
+    Parser parser;
+
+    string code = "const i = 123;";
+    /**
+ConstKeyword
+WhitespaceTrivia
+Identifier
+WhitespaceTrivia
+EqualsToken
+WhitespaceTrivia
+NumericLiteral
+SemicolonToken
+EndOfFileToken
+     */
+
+    auto start = std::chrono::high_resolution_clock::now();
+
+    auto i = 0;
+    for (i = 0; i <10000; i++) {
+        auto result = parser.parseSourceFile("app.ts", code, ts::types::ScriptTarget::Latest, false, ScriptKind::TS, {});
+//        auto sourceFile = parser.createSourceFile("app.ts", ts::types::ScriptTarget::Latest, ScriptKind::TS, false, make_shared<NodeArray>(), make_shared<EndOfFileToken>(), 0, [](auto s) {});
+    }
+    std::chrono::duration<double, std::milli> took = std::chrono::high_resolution_clock::now() - start;
+    debug("parse %d took %fms", i, took.count());
 }
\ No newline at end of file
diff --git a/src/tests/test_scanner.cpp b/src/tests/test_scanner.cpp
index bdc26a4..297f10c 100644
--- a/src/tests/test_scanner.cpp
+++ b/src/tests/test_scanner.cpp
@@ -9,15 +9,35 @@ using namespace ts;
 using namespace magic_enum;
 
 TEST(scanner, basisc) {
+
+    auto start = std::chrono::high_resolution_clock::now();
     Scanner scanner("const i = 123;");
 
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
-    std::cout << enum_name(scanner.scan()) << "\n";
+    auto i = 0;
+    for (i = 0; i <10000; i++) {
+        scanner.setText("const i = 123");
+//        scanner.setOnError([this](auto ...a) { scanError(a...); });
+        scanner.setScriptTarget(ts::types::ScriptTarget::Latest);
+        scanner.setLanguageVariant(ts::types::LanguageVariant::Standard);
+
+        while (scanner.scan() != ts::types::SyntaxKind::EndOfFileToken) {
+
+        }
+
+        scanner.clearCommentDirectives();
+        scanner.setText("");
+        scanner.setOnError(nullopt);
+    }
+    std::chrono::duration<double, std::milli> took = std::chrono::high_resolution_clock::now() - start;
+    debug("scan %d took %fms", i, took.count());
+
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
+//    std::cout << enum_name(scanner.scan()) << "\n";
 }
\ No newline at end of file
diff --git a/src/types.h b/src/types.h
index eae9814..8bc56c3 100644
--- a/src/types.h
+++ b/src/types.h
@@ -1209,15 +1209,15 @@ namespace ts {
     };
 
     template<class T>
-    bool some(optional<NodeArray> array, function<bool(shared<T>)> callback) {
+    bool some(sharedOpt<NodeArray> array, function<bool(shared<T>)> callback) {
         if (!array) return false;
         for (auto &item: array->list) {
-            if (callback(dynamic_pointer_cast<T>(item))) return true;
+            if (callback(reinterpret_pointer_cast<T>(item))) return true;
         }
         return false;
     }
 
-    inline bool some(optional<NodeArray> array) {
+    inline bool some(sharedOpt<NodeArray> array) {
         return array && !array->empty();
     }
 
@@ -1287,8 +1287,8 @@ namespace ts {
         constexpr static auto KIND = SyntaxKind::Unknown;
         /* types::NodeFlags */ int flags;
         /* @internal */ /* types::ModifierFlags */ int modifierFlagsCache;
-        optional<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
-        optional<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
+        sharedOpt<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
+        sharedOpt<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
         /* @internal */ /* types::TransformFlags */ int transformFlags; // Flags for transforms
 //        /* @internal */ id?: NodeId;                          // Unique id (used to look up NodeLinks)
         /* @internal */ sharedOpt<Node> original;                      // The original BaseNode if this is an updated node.
@@ -1350,7 +1350,7 @@ namespace ts {
         return b;
     };
 
-    inline bool operator==(optional<NodeArray> a, optional<NodeArray> b) {
+    inline bool operator==(sharedOpt<NodeArray> a, sharedOpt<NodeArray> b) {
         if (!a && !b) return true;
         if (!a || !b) return false;
         return *a == *b;
@@ -1567,7 +1567,7 @@ namespace ts {
         /*@internal*/ optional</*GeneratedIdentifierFlags*/int> autoGenerateFlags; // Specifies whether to auto-generate the text for an identifier.
         /*@internal*/ optional<int> autoGenerateId;           // Ensures unique generated identifiers get unique names, but clones get the same name.
         /*@internal*/ sharedOpt<ImportSpecifier> generatedImportReference; // Reference to the generated import specifier this identifier refers to
-        /*@internal*/ optional<NodeArray> typeArguments; // Only defined on synthesized nodes. Though not syntactically valid, used in emitting diagnostics, quickinfo, and signature help.
+        /*@internal*/ sharedOpt<NodeArray> typeArguments; // Only defined on synthesized nodes. Though not syntactically valid, used in emitting diagnostics, quickinfo, and signature help.
     };
 
     enum class FlowFlags {
@@ -1590,7 +1590,7 @@ namespace ts {
     };
 
     struct Block: BrandKind<SyntaxKind::Block, Statement> {
-        NodeTypeArray(Statement) statements;
+        shared<NodeTypeArray(Statement)> statements;
         /*@internal*/ bool multiLine;
     };
 
@@ -1657,13 +1657,13 @@ namespace ts {
 #define ArrayBindingElement BindingElement, OmittedExpression
 
     struct ObjectBindingPattern: BrandKind<SyntaxKind::ObjectBindingPattern, Node> {
-        NodeTypeArray(BindingElement) elements;
+        shared<NodeTypeArray(BindingElement)> elements;
         ParentProperty(VariableDeclaration, ParameterDeclaration, BindingElement);
     };
 
     struct ArrayBindingPattern: BrandKind<SyntaxKind::ArrayBindingPattern, Node> {
         ParentProperty(VariableDeclaration, ParameterDeclaration, BindingElement);
-        NodeTypeArray(ArrayBindingElement) elements;
+        shared<NodeTypeArray(ArrayBindingElement)> elements;
     };
 
     struct ExpressionStatement: BrandKind<SyntaxKind::ExpressionStatement, Statement> {
@@ -1719,7 +1719,7 @@ namespace ts {
 
     struct CaseBlock: BrandKind<SyntaxKind::CaseBlock, Node> {
         shared<SwitchStatement> parent;
-        NodeTypeArray(CaseClause, DefaultClause) clauses;
+        shared<NodeTypeArray(CaseClause, DefaultClause)> clauses;
     };
 
     struct SwitchStatement: BrandKind<SyntaxKind::SwitchStatement, Statement> {
@@ -1731,12 +1731,12 @@ namespace ts {
     struct CaseClause: BrandKind<SyntaxKind::CaseClause, Node> {
         Property(parent, CaseBlock);
         Property(expression, Expression);
-        NodeTypeArray(Statement) statements;
+        shared<NodeTypeArray(Statement)> statements;
     };
 
     struct DefaultClause: BrandKind<SyntaxKind::DefaultClause, Node> {
         shared<CaseBlock> parent;
-        NodeTypeArray(Statement) statements;
+        shared<NodeTypeArray(Statement)> statements;
     };
 
 //    export type CaseOrDefaultClause =
@@ -1790,11 +1790,11 @@ namespace ts {
 
     struct VariableDeclarationList: BrandKind<SyntaxKind::VariableDeclarationList, Node> {
         ParentProperty(VariableStatement, ForStatement, ForOfStatement, ForInStatement);
-        NodeTypeArray(VariableDeclaration) declarations;
+        shared<NodeTypeArray(VariableDeclaration)> declarations;
     };
 
     struct VariableStatement: BrandKind<SyntaxKind::VariableStatement, Statement> {
-//        /* @internal*/ optional<NodeTypeArray(Decorator)> decorators; // Present for use with reporting a grammar error
+//        /* @internal*/ sharedOpt<NodeTypeArray(Decorator)> decorators; // Present for use with reporting a grammar error
         Property(declarationList, VariableDeclarationList);
     };
 
@@ -1866,7 +1866,7 @@ namespace ts {
     };
 
     struct TypeLiteralNode: BrandKind<SyntaxKind::TypeLiteral, TypeNode> {
-        NodeTypeArray(TypeElement) members;
+        shared<NodeTypeArray(TypeElement)> members;
     };
 
 #define ClassLikeDeclaration ClassDeclaration, ClassExpression
@@ -1922,10 +1922,10 @@ namespace ts {
 
     struct SignatureDeclarationBase: NamedDeclaration {
         OptionalUnionProperty(name, PropertyName);
-        optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
-        NodeTypeArray(ParameterDeclaration) parameters;
+        sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
+        shared<NodeTypeArray(ParameterDeclaration)> parameters;
         OptionalProperty(type, TypeNode);
-        optional<NodeTypeArray(TypeNode)> typeArguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
     };
 
     struct PropertyAssignment: BrandKind<SyntaxKind::PropertyAssignment, ObjectLiteralElement, Node> {
@@ -1957,14 +1957,14 @@ namespace ts {
 
     struct ClassLikeDeclarationBase {
         OptionalProperty(name, Identifier);
-        optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
-        optional<NodeTypeArray(HeritageClause)> heritageClauses;
-        NodeTypeArray(ClassElement) members;
+        sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
+        sharedOpt<NodeTypeArray(HeritageClause)> heritageClauses;
+        shared<NodeTypeArray(ClassElement)> members;
     };
 
     struct DeclarationStatement: Statement {
-//        optional<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
-//        optional<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
+//        sharedOpt<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
+//        sharedOpt<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
         OptionalUnionProperty(name, Identifier, StringLiteral, NumericLiteral);
     };
 
@@ -1973,7 +1973,7 @@ namespace ts {
     struct DebuggerStatement: BrandKind<SyntaxKind::DebuggerStatement, Statement> {};
 
     struct CommaListExpression: BrandKind<SyntaxKind::CommaListExpression, Expression> {
-        NodeTypeArray(Expression) elements;
+        shared<NodeTypeArray(Expression)> elements;
     };
 
     struct MissingDeclaration: BrandKind<SyntaxKind::MissingDeclaration, DeclarationStatement> {
@@ -1981,27 +1981,27 @@ namespace ts {
     };
 
     struct ClassDeclaration: BrandKind<SyntaxKind::ClassDeclaration, ClassLikeDeclarationBase, DeclarationStatement> {
-//        optional<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
-//        optional<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
+//        sharedOpt<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
+//        sharedOpt<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
         OptionalProperty(name, Identifier);
     };
 
     struct ClassExpression: BrandKind<SyntaxKind::ClassExpression, ClassLikeDeclarationBase, PrimaryExpression> {
-        optional<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
-        optional<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
+        sharedOpt<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
+        sharedOpt<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
     };
 
     struct HeritageClause;
 
     struct InterfaceDeclaration: BrandKind<SyntaxKind::InterfaceDeclaration, DeclarationStatement> {
         Property(name, Identifier);
-        optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
-        optional<NodeTypeArray(HeritageClause)> heritageClauses;
-        NodeTypeArray(TypeElement) members;
+        sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
+        sharedOpt<NodeTypeArray(HeritageClause)> heritageClauses;
+        shared<NodeTypeArray(TypeElement)> members;
     };
 
     struct NodeWithTypeArguments {
-        optional<NodeTypeArray(TypeNode)> typeArguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
     };
 
     struct ExpressionWithTypeArguments: BrandKind<SyntaxKind::ExpressionWithTypeArguments, MemberExpression, NodeWithTypeArguments> {
@@ -2011,12 +2011,12 @@ namespace ts {
     struct HeritageClause: BrandKind<SyntaxKind::HeritageClause, Node> {
         ParentProperty(InterfaceDeclaration, ClassLikeDeclaration);
         SyntaxKind token; //SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword
-        NodeTypeArray(ExpressionWithTypeArguments) types;
+        shared<NodeTypeArray(ExpressionWithTypeArguments)> types;
     };
 
     struct TypeAliasDeclaration: BrandKind<SyntaxKind::TypeAliasDeclaration, DeclarationStatement> {
         Property(name, Identifier);
-        optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
+        sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters;
         Property(type, TypeNode);
     };
 
@@ -2024,7 +2024,7 @@ namespace ts {
 
     struct EnumDeclaration: BrandKind<SyntaxKind::EnumDeclaration, DeclarationStatement> {
         Property(name, Identifier);
-        NodeTypeArray(EnumMember) members;
+        shared<NodeTypeArray(EnumMember)> members;
     };
 
     struct EnumMember: BrandKind<SyntaxKind::EnumMember, NamedDeclaration, Node> {
@@ -2067,7 +2067,7 @@ namespace ts {
 
     struct ModuleBlock: BrandKind<SyntaxKind::ModuleBlock, Statement> {
         shared<ModuleDeclaration> parent;
-        NodeTypeArray(Statement) statements;
+        shared<NodeTypeArray(Statement)> statements;
     };
 
     struct NamespaceDeclaration: BrandKind<SyntaxKind::ModuleDeclaration, DeclarationStatement> {
@@ -2118,7 +2118,7 @@ namespace ts {
 
     struct NamedImports: BrandKind<SyntaxKind::NamedImports, Node> {
         shared<ImportClause> parent;
-        NodeTypeArray(ImportSpecifier) elements;
+        shared<NodeTypeArray(ImportSpecifier)> elements;
     };
 
 #define NamedImportBindings NamespaceImport, NamedImports
@@ -2136,7 +2136,7 @@ namespace ts {
     struct ExportDeclaration;
     struct AssertClause: BrandKind<SyntaxKind::AssertClause, Node> {
         ParentProperty(ImportDeclaration, ExportDeclaration);
-        NodeTypeArray(AssertEntry) elements;
+        shared<NodeTypeArray(AssertEntry)> elements;
         bool multiLine;
     };
 
@@ -2180,12 +2180,12 @@ namespace ts {
 
     struct NamedExports: BrandKind<SyntaxKind::NamedExports, Node> {
         shared<ExportDeclaration> parent;
-        NodeTypeArray(ExportSpecifier) elements;
+        shared<NodeTypeArray(ExportSpecifier)> elements;
     };
 
     struct NamespaceExportDeclaration: BrandKind<SyntaxKind::NamespaceExportDeclaration, DeclarationStatement> {
         Property(name, Identifier);
-        /* @internal */ optional<NodeTypeArray(Decorator)> decorators; // Present for use with reporting a grammar error
+        /* @internal */ sharedOpt<NodeTypeArray(Decorator)> decorators; // Present for use with reporting a grammar error
         /* @internal */ OptionalProperty(modifiers, ModifiersArray); // Present for use with reporting a grammar error
     };
 
@@ -2255,8 +2255,8 @@ namespace ts {
     struct IndexSignatureDeclaration: BrandKind<SyntaxKind::IndexSignature, SignatureDeclarationBase, ClassElement, TypeElement, Node> {
         using TypeElement::name;
         shared<NodeUnion(ObjectTypeDeclaration)> parent;
-//        optional<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
-//        optional<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
+//        sharedOpt<NodeTypeArray(Decorator)> decorators;           // Array of decorators (in document order)
+//        sharedOpt<NodeTypeArray(Modifier)> modifiers;            // Array of modifiers
         Property(type, TypeNode);
     };
 
@@ -2296,7 +2296,7 @@ namespace ts {
         shared<NodeUnion(ClassLikeDeclaration)> parent;
         OptionalProperty(body, FunctionBody);
 
-        /* @internal */ optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters; // Present for use with reporting a grammar error
+        /* @internal */ sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters; // Present for use with reporting a grammar error
         /* @internal */ OptionalProperty(type, TypeNode); // Present for use with reporting a grammar error
     };
 
@@ -2308,7 +2308,7 @@ namespace ts {
         ParentProperty(ClassLikeDeclaration, ObjectLiteralExpression, TypeLiteralNode, InterfaceDeclaration);
         UnionProperty(name, PropertyName);
         OptionalProperty(body, FunctionBody);
-        /* @internal */ optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters; // Present for use with reporting a grammar error
+        /* @internal */ sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters; // Present for use with reporting a grammar error
     };
 
     // See the comment on MethodDeclaration for the intuition behind SetAccessorDeclaration being a
@@ -2317,7 +2317,7 @@ namespace ts {
         ParentProperty(ClassLikeDeclaration, ObjectLiteralExpression, TypeLiteralNode, InterfaceDeclaration);
         UnionProperty(name, PropertyName);
         OptionalUnionProperty(body, FunctionBody);
-        /* @internal */ optional<NodeTypeArray(TypeParameterDeclaration)> typeParameters; // Present for use with reporting a grammar error
+        /* @internal */ sharedOpt<NodeTypeArray(TypeParameterDeclaration)> typeParameters; // Present for use with reporting a grammar error
         /* @internal */ OptionalProperty(type, TypeNode); // Present for use with reporting a grammar error
     };
 
@@ -2327,7 +2327,7 @@ namespace ts {
 
     template<class T>
     struct ObjectLiteralExpressionBase: PrimaryExpression {
-        NodeTypeArray(T) properties;
+        shared<NodeTypeArray(T)> properties;
     };
 
     struct ObjectLiteralExpression: BrandKind<SyntaxKind::ObjectLiteralExpression, ObjectLiteralExpressionBase<ObjectLiteralElementLike>> {
@@ -2432,7 +2432,7 @@ namespace ts {
     };
 
     struct ArrayLiteralExpression: BrandKind<SyntaxKind::ArrayLiteralExpression, PrimaryExpression> {
-        NodeTypeArray(Expression) elements;
+        shared<NodeTypeArray(Expression)> elements;
         /* @internal */
         bool multiLine; //optional
     };
@@ -2445,8 +2445,8 @@ namespace ts {
     struct CallExpression: BrandKind<SyntaxKind::CallExpression, LeftHandSideExpression> {
         Property(expression, LeftHandSideExpression);
         OptionalProperty(questionDotToken, QuestionDotToken);
-        optional<NodeTypeArray(TypeNode)> typeArguments;
-        NodeTypeArray(Expression) arguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
+        shared<NodeTypeArray(Expression)> arguments;
     };
 
     using CallChain = CallExpression;
@@ -2457,8 +2457,8 @@ namespace ts {
 
     struct NewExpression: BrandKind<SyntaxKind::NewExpression, PrimaryExpression> {
         Property(expression, LeftHandSideExpression);
-        optional<NodeTypeArray(TypeNode)> typeArguments;
-        optional<NodeTypeArray(Expression)> arguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
+        sharedOpt<NodeTypeArray(Expression)> arguments;
     };
 
     struct TypeAssertion: BrandKind<SyntaxKind::TypeAssertionExpression, UnaryExpression> {
@@ -2497,19 +2497,19 @@ namespace ts {
 
     struct TemplateLiteralTypeNode: BrandKind<SyntaxKind::TemplateLiteralType, TypeNode> {
         Property(head, TemplateHead);
-        NodeTypeArray(TemplateLiteralTypeSpan) templateSpans;
+        shared<NodeTypeArray(TemplateLiteralTypeSpan)> templateSpans;
     };
 
     struct TemplateExpression: BrandKind<SyntaxKind::TemplateExpression, PrimaryExpression> {
         Property(head, TemplateHead);
-        NodeTypeArray(TemplateSpan) templateSpans;
+        shared<NodeTypeArray(TemplateSpan)> templateSpans;
     };
 
 #define TemplateLiteral TemplateExpression, NoSubstitutionTemplateLiteral
 
     struct TaggedTemplateExpression: BrandKind<SyntaxKind::TaggedTemplateExpression, MemberExpression> {
         Property(tag, LeftHandSideExpression);
-        optional<NodeTypeArray(TypeNode)> typeArguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
         UnionProperty(templateLiteral, TemplateLiteral);
         /*@internal*/ OptionalProperty(questionDotToken, QuestionDotToken); // NOTE: Invalid syntax, only used to report a grammar error.
     };
@@ -2564,11 +2564,11 @@ namespace ts {
     };
 
     struct UnionTypeNode: BrandKind<SyntaxKind::UnionType, TypeNode> {
-        NodeTypeArray(TypeNode) types;
+        shared<NodeTypeArray(TypeNode)> types;
     };
 
     struct IntersectionTypeNode: BrandKind<SyntaxKind::IntersectionType, TypeNode> {
-        NodeTypeArray(TypeNode) types;
+        shared<NodeTypeArray(TypeNode)> types;
     };
 
 #define UnionOrIntersectionTypeNode UnionTypeNode, IntersectionTypeNode
@@ -2610,7 +2610,7 @@ namespace ts {
         OptionalUnionProperty(questionToken, QuestionToken, PlusToken, MinusToken);
         OptionalProperty(type, TypeNode);
         /** Used only to produce grammar errors */
-        optional<NodeTypeArray(TypeElement)> members;
+        sharedOpt<NodeTypeArray(TypeElement)> members;
     };
 
 #define JsxChild JsxText, JsxExpression, JsxElement, JsxSelfClosingElement, JsxFragment
@@ -2647,14 +2647,14 @@ namespace ts {
 
     struct JsxAttributes: BrandKind<SyntaxKind::JsxAttributes, PrimaryExpression> {
         OptionalUnionProperty(parent, JsxOpeningLikeElement);
-        NodeTypeArray(JsxAttributeLike) properties;
+        shared<NodeTypeArray(JsxAttributeLike)> properties;
     };
 
     // The opening element of a <Tag>...</Tag> JsxElement
     struct JsxOpeningElement: BrandKind<SyntaxKind::JsxOpeningElement, Expression> {
         shared<JsxElement> parent;
         UnionProperty(tagName, JsxTagNameExpression);
-        optional<NodeTypeArray(TypeNode)> typeArguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
         Property(attributes, JsxAttributes);
     };
 
@@ -2671,7 +2671,7 @@ namespace ts {
     /// A JSX expression of the form <TagName attrs>...</TagName>
     struct JsxElement: BrandKind<SyntaxKind::JsxElement, PrimaryExpression> {
         Property(openingElement, JsxOpeningElement);
-        NodeTypeArray(JsxChild) children;
+        shared<NodeTypeArray(JsxChild)> children;
         Property(closingElement, JsxClosingElement);
     };
 
@@ -2683,7 +2683,7 @@ namespace ts {
     // A JSX expression of the form <TagName attrs />
     struct JsxSelfClosingElement: BrandKind<SyntaxKind::JsxSelfClosingElement, PrimaryExpression> {
         UnionProperty(tagName, JsxTagNameExpression);
-        optional<NodeTypeArray(TypeNode)> typeArguments;
+        sharedOpt<NodeTypeArray(TypeNode)> typeArguments;
         Property(attributes, JsxAttributes);
     };
 
@@ -2701,7 +2701,7 @@ namespace ts {
     /// A JSX expression of the form <>...</>
     struct JsxFragment: BrandKind<SyntaxKind::JsxFragment, PrimaryExpression> {
         Property(openingFragment, JsxOpeningFragment);
-        NodeTypeArray(JsxChild) children;
+        shared<NodeTypeArray(JsxChild)> children;
         Property(closingFragment, JsxClosingFragment);
     };
 
@@ -2715,7 +2715,7 @@ namespace ts {
     };
 
     struct TupleTypeNode: BrandKind<SyntaxKind::TupleType, TypeNode> {
-        NodeTypeArray(TypeNode, NamedTupleMember) elements;
+        shared<NodeTypeArray(TypeNode, NamedTupleMember)> elements;
     };
 
 //    using AccessibilityModifier = NodeType<PublicKeyword, PrivateKeyword, ProtectedKeyword>;
@@ -2731,11 +2731,128 @@ namespace ts {
 
     struct SourceFile: BrandKind<SyntaxKind::SourceFile, Node> {
         string fileName;
-        NodeTypeArray(Statement) statements;
+        string text;
+
+        shared<NodeTypeArray(Statement)> statements;
         Property(endOfFileToken, EndOfFileToken);
 
-        optional<types::ModuleKind> impliedNodeFormat;
+        /* @internal */ string path;
+        /** Resolved path can be different from path property,
+         * when file is included through project reference is mapped to its output instead of source
+         * in that case resolvedPath = path to output file
+         * path = input file's path
+         */
+        /* @internal */ string resolvedPath;
+
+        /** Original file name that can be different from fileName,
+         * when file is included through project reference is mapped to its output instead of source
+         * in that case originalFileName = name of input file
+         * fileName = output file's name
+         */
+        /* @internal */ string originalFileName;
+
+//        amdDependencies: readonly AmdDependency[];
+        optional<string> moduleName;
+//        referencedFiles: readonly FileReference[];
+//        typeReferenceDirectives: readonly FileReference[];
+//        libReferenceDirectives: readonly FileReference[];
+        types::LanguageVariant languageVariant;
+        bool isDeclarationFile;
+//
+//        // this map is used by transpiler to supply alternative names for dependencies (i.e. in case of bundling)
+//        /* @internal */
+//        renamedDependencies?: ReadonlyESMap<string, string>;
+//
+        /**
+         * lib.d.ts should have a reference comment like
+         *
+         *  /// <reference no-default-lib="true"/>
+         *
+         * If any other file has this comment, it signals not to include lib.d.ts
+         * because this containing file is intended to act as a default library.
+         */
+        bool hasNoDefaultLib;
+
+        types::ScriptTarget languageVersion;
+
+        /**
+         * When `module` is `Node16` or `NodeNext`, this field controls whether the
+         * source file in question is an ESNext-output-format file, or a CommonJS-output-format
+         * module. This is derived by the module resolver as it looks up the file, since
+         * it is derived from either the file extension of the module, or the containing
+         * `package.json` context, and affects both checking and emit.
+         *
+         * It is _public_ so that (pre)transformers can set this field,
+         * since it switches the builtin `node` module transform. Generally speaking, if unset,
+         * the field is treated as though it is `ModuleKind.CommonJS`.
+         */
+        optional<types::ModuleKind> impliedNodeFormat; //?: ModuleKind.ESNext | ModuleKind.CommonJS;
+
+        /* @internal */ types::ScriptKind scriptKind;
+
+        /**
+         * The first "most obvious" node that makes a file an external module.
+         * This is intended to be the first top-level import/export,
+         * but could be arbitrarily nested (e.g. `import.meta`).
+         */
+        /* @internal */ sharedOpt<Node> externalModuleIndicator; //?: Node | true;
+
+        /**
+         * The callback used to set the external module indicator - this is saved to
+         * be later reused during incremental reparsing, which otherwise lacks the information
+         * to set this field
+         */
+        /* @internal */ optional<function<void(shared<SourceFile>)>> setExternalModuleIndicator; //?: (file: SourceFile) => void;
+//        // The first node that causes this file to be a CommonJS module
+//        /* @internal */ commonJsModuleIndicator?: Node;
+//        // JS identifier-declarations that are intended to merge with globals
+//        /* @internal */ jsGlobalAugmentations?: SymbolTable;
+//
+//        /* @internal */ identifiers: ESMap<string, string>; // Map from a string to an interned string
+//        /* @internal */ nodeCount: number;
+//        /* @internal */ identifierCount: number;
+//        /* @internal */ symbolCount: number;
+//
+//        // File-level diagnostics reported by the parser (includes diagnostics about /// references
+//        // as well as code diagnostics).
+//        /* @internal */ parseDiagnostics: DiagnosticWithLocation[];
+//
+//        // File-level diagnostics reported by the binder.
+//        /* @internal */ bindDiagnostics: DiagnosticWithLocation[];
+//        /* @internal */ bindSuggestionDiagnostics?: DiagnosticWithLocation[];
+//
+//        // File-level JSDoc diagnostics reported by the JSDoc parser
+//        /* @internal */ jsDocDiagnostics?: DiagnosticWithLocation[];
+//
+//        // Stores additional file-level diagnostics reported by the program
+//        /* @internal */ additionalSyntacticDiagnostics?: readonly DiagnosticWithLocation[];
+//
+//        // Stores a line map for the file.
+//        // This field should never be used directly to obtain line map, use getLineMap function instead.
+//        /* @internal */ lineMap: readonly number[];
+//        /* @internal */ classifiableNames?: ReadonlySet<__String>;
+//        // Comments containing @ts-* directives, in order.
+//        /* @internal */ commentDirectives?: CommentDirective[];
+//        // Stores a mapping 'external module reference text' -> 'resolved file name' | undefined
+//        // It is used to resolve module names in the checker.
+//        // Content of this field should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead
+//        /* @internal */ resolvedModules?: ModeAwareCache<ResolvedModuleFull | undefined>;
+//        /* @internal */ resolvedTypeReferenceDirectiveNames: ModeAwareCache<ResolvedTypeReferenceDirective | undefined>;
+//        /* @internal */ imports: readonly StringLiteralLike[];
+//        // Identifier only if `declare global`
+//        /* @internal */ moduleAugmentations: readonly (StringLiteral | Identifier)[];
+//        /* @internal */ patternAmbientModules?: PatternAmbientModule[];
+//        /* @internal */ ambientModuleNames: readonly string[];
+//        /* @internal */ checkJsDirective?: CheckJsDirective;
+//        /* @internal */ version: string;
+//        /* @internal */ pragmas: ReadonlyPragmaMap;
+//        /* @internal */ localJsxNamespace?: __String;
+//        /* @internal */ localJsxFragmentNamespace?: __String;
+//        /* @internal */ localJsxFactory?: EntityName;
+//        /* @internal */ localJsxFragmentFactory?: EntityName;
+//
+//        /* @internal */ exportedModulesFromDeclarationEmit?: ExportedModulesFromDeclarationEmit;
+//        /* @internal */ endFlowNode?: FlowNode;
 
-        sharedOpt<Node> externalModuleIndicator;
     };
 }
\ No newline at end of file
diff --git a/src/utilities.cpp b/src/utilities.cpp
index 75f56c4..5f54441 100644
--- a/src/utilities.cpp
+++ b/src/utilities.cpp
@@ -1,15 +1,17 @@
 #pragma once
 
+#include "Tracy.hpp"
+#include "types.h"
 #include "utilities.h"
 #include "core.h"
 
 namespace ts {
-    static LanguageVariant getLanguageVariant(ScriptKind scriptKind) {
+    LanguageVariant getLanguageVariant(ScriptKind scriptKind) {
         // .tsx and .jsx files are treated as jsx language variant.
         return scriptKind == ScriptKind::TSX || scriptKind == ScriptKind::JSX || scriptKind == ScriptKind::JS || scriptKind == ScriptKind::JSON ? LanguageVariant::JSX : LanguageVariant::Standard;
     }
 
-    sharedOpt<Node> lastOrUndefined(optional<NodeArray> array) {
+    sharedOpt<Node> lastOrUndefined(sharedOpt<NodeArray> array) {
         if (!array) return nullptr;
         auto last = lastOrUndefined(array->list);
         if (last) *last;
@@ -426,6 +428,7 @@ namespace ts {
     }
 
     shared<Node> skipPartiallyEmittedExpressions(shared<Node> node) {
+        ZoneScoped;
         return skipOuterExpressions(node, (int) OuterExpressionKinds::PartiallyEmittedExpressions);
     }
 
@@ -610,6 +613,7 @@ namespace ts {
     }
 
     bool isLeftHandSideExpression(shared<Node> node) {
+        ZoneScoped;
         return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node)->kind);
     }
 
diff --git a/src/utilities.h b/src/utilities.h
index be9f22a..fb5998c 100644
--- a/src/utilities.h
+++ b/src/utilities.h
@@ -23,9 +23,9 @@ namespace ts {
     using types::DiagnosticCategory;
     using types::DiagnosticWithDetachedLocation;
 
-    static vector<const char *> supportedDeclarationExtensions{Extension::Dts, Extension::Dcts, Extension::Dmts};
+    inline vector<const char *> supportedDeclarationExtensions{Extension::Dts, Extension::Dcts, Extension::Dmts};
 
-    static LanguageVariant getLanguageVariant(ScriptKind scriptKind);
+    extern LanguageVariant getLanguageVariant(ScriptKind scriptKind);
 
     /* @internal */
     template<typename T>
@@ -35,7 +35,12 @@ namespace ts {
         return range;
     }
 
-    sharedOpt<Node> lastOrUndefined(optional<NodeArray> array);
+    template<typename T, typename T2>
+    T setTextRange(T range, T2 location) {
+        return location ? setTextRangePosEnd<T>(range, location->pos, location->end) : range;
+    }
+
+    sharedOpt<Node> lastOrUndefined(sharedOpt<NodeArray> array);
 
     NodeArray &setTextRangePosEnd(NodeArray &range, int pos, int end);
 
@@ -57,11 +62,6 @@ namespace ts {
 
     bool nodeIsSynthesized(shared<TextRange> range);
 
-    template<typename T>
-    T setTextRange(T range, sharedOpt<Node> location) {
-        return location ? setTextRangePosEnd(range, location->pos, location->end) : range;
-    }
-
     NodeArray setTextRange(NodeArray range, optional<NodeArray> location);
 
     string parsePseudoBigInt(string &stringValue);