Function declareSymbolAndAddToSymbolTable

test/fixtures/snapshot/typescript.js:46277–46331

(node, symbolFlags, symbolExcludes)

            lastContainer = next;
        }
        function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
            switch (container.kind) {
                // Modules, source files, and classes need specialized handling for how their
                // members are declared (for example, a member of a class will go into a specific
                // symbol table depending on if it is static or not). We defer to specialized
                // handlers to take care of declaring these child members.
                case 261 /* SyntaxKind.ModuleDeclaration */:
                    return declareModuleMember(node, symbolFlags, symbolExcludes);
                case 305 /* SyntaxKind.SourceFile */:
                    return declareSourceFileMember(node, symbolFlags, symbolExcludes);
                case 226 /* SyntaxKind.ClassExpression */:
                case 257 /* SyntaxKind.ClassDeclaration */:
                    return declareClassMember(node, symbolFlags, symbolExcludes);
                case 260 /* SyntaxKind.EnumDeclaration */:
                    return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
                case 182 /* SyntaxKind.TypeLiteral */:
                case 322 /* SyntaxKind.JSDocTypeLiteral */:
                case 205 /* SyntaxKind.ObjectLiteralExpression */:
                case 258 /* SyntaxKind.InterfaceDeclaration */:
                case 286 /* SyntaxKind.JsxAttributes */:
                    // Interface/Object-types always have their children added to the 'members' of
                    // their container. They are only accessible through an instance of their
                    // container, and are never in scope otherwise (even inside the body of the
                    // object / type / interface declaring them). An exception is type parameters,
                    // which are in scope without qualification (similar to 'locals').
                    return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
                case 179 /* SyntaxKind.FunctionType */:
                case 180 /* SyntaxKind.ConstructorType */:
                case 174 /* SyntaxKind.CallSignature */:
                case 175 /* SyntaxKind.ConstructSignature */:
                case 323 /* SyntaxKind.JSDocSignature */:
                case 176 /* SyntaxKind.IndexSignature */:
                case 169 /* SyntaxKind.MethodDeclaration */:
                case 168 /* SyntaxKind.MethodSignature */:
                case 171 /* SyntaxKind.Constructor */:
                case 172 /* SyntaxKind.GetAccessor */:
                case 173 /* SyntaxKind.SetAccessor */:
                case 256 /* SyntaxKind.FunctionDeclaration */:
                case 213 /* SyntaxKind.FunctionExpression */:
                case 214 /* SyntaxKind.ArrowFunction */:
                case 317 /* SyntaxKind.JSDocFunctionType */:
                case 345 /* SyntaxKind.JSDocTypedefTag */:
                case 338 /* SyntaxKind.JSDocCallbackTag */:
                case 170 /* SyntaxKind.ClassStaticBlockDeclaration */:
                case 259 /* SyntaxKind.TypeAliasDeclaration */:
                case 195 /* SyntaxKind.MappedType */:
                    // All the children of these container types are never visible through another
                    // symbol (i.e. through another symbol's 'exports' or 'members').  Instead,
                    // they're only accessed 'lexically' (i.e. from code that exists underneath
                    // their container in the tree). To accomplish this, we simply add their declared
                    // symbol to the 'locals' of the container.  These symbols can then be found as
                    // the type checker walks up the containers, checking them for matching names.
                    return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes);
            }
        }
        function declareClassMember(node, symbolFlags, symbolExcludes) {
            return ts.isStatic(node)
                ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)