export function linkSymbols()

in build-scripts/doc-gen/util.ts [555:654]
85 lines of code
10 McCabe index (conditional complexity)

export function linkSymbols(
    docs: Docs, symbols: SymbolAndUrl[], toplevelNamespace: string,
    docLinkAliases: {[symbolName: string]: string}) {
  // Find all the symbols.
  docs.headings.forEach(heading => {
    heading.subheadings.forEach(subheading => {
      subheading.symbols.forEach(symbol => {
        const namespace =
            (symbol.namespace != null && symbol.namespace != '' ?
                 symbol.namespace + '.' :
                 '');

        if (toplevelNamespace.length > 0) {
          symbol.displayName =
              toplevelNamespace + '.' + namespace + symbol.symbolName;
        } else {
          symbol.displayName = namespace + symbol.symbolName
        }


        const referenceName = namespace + symbol.symbolName;
        symbol.urlHash = (symbol['isClass'] ? 'class:' : '') + referenceName;

        symbols.push({
          referenceName,
          symbolName: symbol.symbolName,
          url: '#' + symbol.urlHash,
          type: symbol['isClass'] != null ? 'class' : 'function',
          toplevelNamespace
        });

        if (symbol['isClass'] != null) {
          const docClass = symbol as DocClass;
          docClass.methods.forEach(method => {
            method.urlHash = docClass.displayName + '.' + method.symbolName;
            symbols.push({
              referenceName: referenceName + '.' + method.symbolName,
              symbolName: method.symbolName,
              url: '#' + method.urlHash,
              type: 'method',
              toplevelNamespace
            });
          });
        }
      });
    });
  });

  // Add new doc link alias symbols.
  Object.keys(docLinkAliases).forEach(docLinkAlias => {
    // Find the symbol so we can find the url hash.
    symbols.forEach(symbol => {
      if (symbol.symbolName === docLinkAliases[docLinkAlias]) {
        symbols.push({
          symbolName: docLinkAlias,
          referenceName: docLinkAlias,
          url: symbol.url,
          type: symbol.type,
          toplevelNamespace: symbol.toplevelNamespace
        });
      }
    });
  });

  // Replace class documentation with links.
  docs.headings.forEach(heading => {
    heading.subheadings.forEach(subheading => {
      subheading.symbols.forEach(symbol => {
        if (symbol['isClass']) {
          symbol.documentation = replaceSymbolsWithLinks(
              symbol.documentation, symbols, true /** isMarkdown */);
          const classSymbol = symbol as DocClass;
          if (classSymbol.inheritsFrom != null) {
            classSymbol.inheritsFrom = replaceSymbolsWithLinks(
                classSymbol.inheritsFrom, symbols, false /** isMarkdown */,
                true /** replaceFromSymbolName */);
          }
        }
      });
    });
  });

  foreachDocFunction(docs.headings, method => {
    method.documentation = replaceSymbolsWithLinks(
        method.documentation, symbols, true /** isMarkdown */);

    // Since automatic types do not have namespaces, we must replace using
    // just the symbol names.
    method.returnType = replaceSymbolsWithLinks(
        method.returnType, symbols, false /** isMarkdown */,
        true /** replaceFromSymbolName */);
    method.parameters.forEach(param => {
      param.documentation = replaceSymbolsWithLinks(
          param.documentation, symbols, true /** isMarkdown */);
      param.type = replaceSymbolsWithLinks(
          param.type, symbols, false /** isMarkdown */,
          true /** replaceFromSymbolName */);
    });
  });
}