docs: function declareSymbol(symbolTable, parent, node, includes, excludes) {
              ts.Debug.assert(!ts.hasDynamicName(node));
              var isDefaultExport = node.flags & 512 /* Default */;
              // The exported symbol for an export default function/class node is always named "default"
              var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
              var symbol;
              if (name === undefined) {
                  symbol = createSymbol(0 /* None */, "__missing");
              }
              else {
                  // Check and see if the symbol table already has a symbol with this name.  If not,
                  // create a new symbol with this name and add it to the table.  Note that we don't
                  // give the new symbol any flags *yet*.  This ensures that it will not conflict
                  // with the 'excludes' flags we pass in.
                  //
                  // If we do get an existing symbol, see if it conflicts with the new symbol we're
                  // creating.  For example, a 'var' symbol and a 'class' symbol will conflict within
                  // the same symbol table.  If we have a conflict, report the issue on each
                  // declaration we have for this symbol, and then create a new symbol for this
                  // declaration.
                  //
                  // Note that when properties declared in Javascript constructors
                  // (marked by isReplaceableByMethod) conflict with another symbol, the property loses.
                  // Always. This allows the common Javascript pattern of overwriting a prototype method
                  // with an bound instance method of the same type: `this.method = this.method.bind(this)`
                  //
                  // If we created a new symbol, either because we didn't have a symbol with this name
                  // in the symbol table, or we conflicted with an existing symbol, then just add this
                  // node as the sole declaration of the new symbol.
                  //
                  // Otherwise, we'll be merging into a compatible existing symbol (for example when
                  // you have multiple 'vars' with the same name in the same container).  In this case
                  // just add this node into the declarations list of the symbol.
                  symbol = symbolTable[name] || (symbolTable[name] = createSymbol(0 /* None */, name));
                  if (name && (includes & 788448 /* Classifiable */)) {
                      classifiableNames[name] = name;
                  }
                  if (symbol.flags & excludes) {
                      if (symbol.isReplaceableByMethod) {
                          // Javascript constructor-declared symbols can be discarded in favor of
                          // prototype symbols like methods.
                          symbol = symbolTable[name] = createSymbol(0 /* None */, name);
                      }
                      else {
                          if (node.name) {
                              node.name.parent = node;
                          }
                          // Report errors every position with duplicate declaration
                          // Report errors on previous encountered declarations
                          var message_1 = symbol.flags & 2 /* BlockScopedVariable */
                              ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                              : ts.Diagnostics.Duplicate_identifier_0;
                          ts.forEach(symbol.declarations, function (declaration) {
                              if (declaration.flags & 512 /* Default */) {
                                  message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
                              }
                          });
                          ts.forEach(symbol.declarations, function (declaration) {
                              file.bindDiagnostics.push(ts.createDiagnosticForNode(declaration.name || declaration, message_1, getDisplayName(declaration)));
                          });
                          file.bindDiagnostics.push(ts.createDiagnosticForNode(node.name || node, message_1, getDisplayName(node)));
                          symbol = createSymbol(0 /* None */, name);
                      }
                  }
              }
              addDeclarationToSymbol(symbol, node, includes);
              symbol.parent = parent;
              return symbol;
          }