Not all symbol tables record references to "namespace" objects. For example, if you have:
goog.dom.DomHelper = function() {}; The symbol table may not record that as a reference to
"goog.dom", because that would be redundant.
967217
void fillNamespaceReferences() {
    for (Symbol symbol : getAllSymbols()) {
      String qName = symbol.getName();
      int rootIndex = qName.indexOf('.');
      if (rootIndex == -1) {
        continue;
      }

      Symbol root = symbol.scope.getQualifiedSlot(qName.substring(0, rootIndex));
      if (root == null) {
        // In theory, this should never happen, but we fail quietly anyway
        // just to be safe.
        continue;
      }

      for (Reference ref : getReferences(symbol)) {
        Node currentNode = ref.getNode();
        if (!currentNode.isQualifiedName()) {
          continue;
        }

        while (currentNode.isGetProp()) {
          currentNode = currentNode.getFirstChild();

          String name = currentNode.getQualifiedName();
          if (name != null) {
            Symbol namespace = isAnySymbolDeclared(name, currentNode, root.scope);
            if (namespace == null) {
              namespace = root.scope.getQualifiedSlot(name);
            }

            if (namespace == null && root.scope.isGlobalScope()) {
              namespace =
                  declareSymbol(
                      name,
                      registry.getNativeType(JSTypeNative.UNKNOWN_TYPE),
                      true,
                      root.scope,
                      currentNode,
                      null /* JsDoc info */);
            }

            if (namespace != null) {
              namespace.defineReferenceAt(currentNode);
            }
          }
        }
      }
    }
  }
932822
function (namespace) {
			var result,
				aNamespaceParts = namespace.split(".");

			if (aNamespaceParts[0] === "Org" && aNamespaceParts[1] === "OData") {
				result = '<a href="' + this.ANNOTATIONS_NAMESPACE_LINK + namespace + '.xml">' + namespace + '</a>';
			} else {
				result = namespace;
			}

			result = this._preProcessLinksInTextBlock(result);
			return result;
		}
885055
function Reference(ident, scope, flag,writeExpr, maybeImplicitGlobal, partial, init) {
      /**
       * Identifier syntax node.
       * @member {esprima#Identifier} Reference#identifier
       */
      this.identifier = ident;
      /**
       * Reference to the enclosing Scope.
       * @member {Scope} Reference#from
       */
      this.from = scope;
      /**
       * Whether the reference comes from a dynamic scope (such as 'eval',
       * 'with', etc.), and may be trapped by dynamic scopes.
       * @member {boolean} Reference#tainted
       */
      this.tainted = false;
      /**
       * The variable this reference is resolved with.
       * @member {Variable} Reference#resolved
       */
      this.resolved = null;
      /**
       * The read-write mode of the reference. (Value is one of {@link
       * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).
       * @member {number} Reference#flag
       * @private
       */
      this.flag = flag;
      if (this.isWrite()) {
          /**
           * If reference is writeable, this is the tree being written to it.
           * @member {esprima#Node} Reference#writeExpr
           */
          this.writeExpr = writeExpr;
          /**
           * Whether the Reference might refer to a partial value of writeExpr.
           * @member {boolean} Reference#partial
           */
          this.partial = partial;
          /**
           * Whether the Reference is to write of initialization.
           * @member {boolean} Reference#init
           */
          this.init = init;
      }
      this.__maybeImplicitGlobal = maybeImplicitGlobal;
  }
20523
function publishClasses(symbols, aRootNamespaces, hierarchyRoots) {

	// create output dir
	fs.mkPath(path.join(conf.outdir, conf.symbolsDir));

	// get a list of all the first class symbols in the symbolset
	var firstClassSymbols = symbols(function() {
		return supportsInheritance(this) && conf.filter(this);
	}).order("longname");

	// create unique file names
	__uniqueFilenames = {};
	var filenames = {};
	firstClassSymbols.get().sort(sortByAlias).forEach(function(symbol) {
		var filename = escape(symbol.longname.replace(/^module:/, "")).replace(/\//g, "%25");
		if ( filenames.hasOwnProperty(filename.toUpperCase()) && (filenames[filename.toUpperCase()].longname !== symbol.longname) ) {
			// find an unused filename by appending "-n" where n is an integer > 0
			var j = 1;
			while (filenames.hasOwnProperty(filename.toUpperCase() + "-" + j)) {
				j++;
			}
			warning("duplicate symbol names " + filenames[filename.toUpperCase()].longname + " and " + symbol.longname  + ", renaming the latter to " + filename + "-" + j);
			filename = filename + "-" + j;
		}
		filenames[filename.toUpperCase()] = symbol;
		__uniqueFilenames[symbol.longname] = filename;
	});
	filenames = null;

	// create a class index, displayed in the left-hand column of every class page
	var classTemplate;
	if ( !conf.contentOnly ) {
		info("create embedded class index");
		Link.base = "../";
		Link.baseSymbols = "";
		classTemplate = 'classWithIndex.html.tmpl';
		publish.header = processTemplate("_header.tmpl", firstClassSymbols);
		publish.footer = processTemplate("_footer.tmpl", firstClassSymbols);
		publish.classesIndex = processTemplate("_navIndex.tmpl", firstClassSymbols); // kept in memory
	} else {
		var newStyle = !!pluginConf.newStyle;
		classTemplate = newStyle ? "class-new.html.tmpl" : "class.html.tmpl";
		publish.header = '';
		publish.footer = '';
		publish.classesIndex = '';

		// instead create an index as XML
		Link.base = "";
		Link.baseSymbols = conf.symbolsDir;
		processTemplateAndSave("index.xml.tmpl", aRootNamespaces, "index.xml");
	}

	// create each of the class pages
	info("create class/namespace pages");
	Link.base = "../";
	Link.baseSymbols = "";
	firstClassSymbols.each(function(symbol) {
		var sOutName = path.join(conf.symbolsDir, __uniqueFilenames[symbol.longname]) + conf.ext;
		processTemplateAndSave(classTemplate, symbol, sOutName);
	});

	if ( conf.modulePages ) {
		info("create module pages");
		Link.base = "../";
		Link.baseSymbols = "../" + conf.symbolsDir;
		fs.mkPath(path.join(conf.outdir, conf.modulesDir));
		groupByModule(firstClassSymbols.get()).forEach(function(module) {
			var sOutName = path.join(conf.modulesDir, module.name.replace(/\//g, '_')) + conf.ext;
			processTemplateAndSave("module.html.tmpl", module, sOutName);
		});
	}

	// regenerate the index with a different link base, used in the overview pages
	info("create global class/namespace index");
	Link.base = "";
	Link.baseSymbols = conf.symbolsDir;
	publish.header = processTemplate("_header.tmpl", firstClassSymbols);
	publish.footer = processTemplate("_footer.tmpl", firstClassSymbols);
	publish.classesIndex = processTemplate("_navIndex.tmpl", firstClassSymbols);

	// create the all classes index
	processTemplateAndSave("index.html.tmpl", firstClassSymbols, "index" + conf.ext);

	// create the class hierarchy page
	if ( conf.hierarchyIndex ) {
		info("create class hierarchy index");
		Link.base = "";
		Link.baseSymbols = conf.symbolsDir;
		processTemplateAndSave("hierarchy.html.tmpl", hierarchyRoots.filter(conf.filter), "hierarchy" + conf.ext);
	}

	if ( conf.sinceIndex ) {
		info("create API by version index");
		Link.base = "";
		Link.baseSymbols = conf.symbolsDir;
		var sinceSymbols = symbols(function() {
			var r = !!this.since && !this.inherited && conf.filter(this);
			if ( r && this.memberof ) {
				var parent = lookup(this.memberof);
				// filter out symbol when parent is filtered out
				if ( !parent || !conf.filter(parent) ) {
					debug("since index: filtering out " + this.longname + ", member of " + this.memberof);
					r = false;
				}
				if ( parent && parent.since === this.since ) {
					// r = false;
				}
			}
			return r;
		}).order("longname");
		processTemplateAndSave("since.html.tmpl", sinceSymbols, "since" + conf.ext);
	}

	if ( conf.deprecationIndex ) {
		info("create deprecated API index");
		Link.base = "";
		Link.baseSymbols = conf.symbolsDir;
		var deprecatedSymbols = symbols(function() {
			return !!this.deprecated && !this.inherited && conf.filter(this);
		}).order("longname");
		processTemplateAndSave("deprecation.html.tmpl", deprecatedSymbols, "deprecation" + conf.ext);
	}

	if ( conf.experimentalIndex ) {
		info("create experimental API index");
		Link.base = "";
		Link.baseSymbols = conf.symbolsDir;
		var experimentalSymbols = symbols(function() {
			return !!this.experimental && !this.inherited && conf.filter(this);
		}).order("longname");
		processTemplateAndSave("experimental.html.tmpl", experimentalSymbols, "experimental" + conf.ext);
	}

	if ( conf.securityIndex ) {
		info("create Security Relevant API index");

		var securityRelevantSymbols = {};
		A_SECURITY_TAGS.forEach(function(oTagDef) {
			securityRelevantSymbols[oTagDef.name.toLowerCase()] = { tag : oTagDef, symbols: [] };
		});
		symbols().each(function($) {
			var tags = $.tags;
			if ( !$.inherited  && conf.filter($) && tags ) {
				for (var i = 0; i < tags.length; i++) {
					if ( rSecurityTags.test(tags[i].title) ) {
						securityRelevantSymbols[tags[i].title.toLowerCase()].symbols.push({ symbol: $, tag : tags[i]});
					}
				}
			}
		});

		Link.base = "";
		Link.baseSymbols = conf.symbolsDir;
		processTemplateAndSave("security.html.tmpl", securityRelevantSymbols, "security" + conf.ext);
	}

	firstClassSymbols = null;

	// copy needed mimes
	info("copy mimes");
	// copy the template's static files to outdir
	var templatePath = env.opts.template;
	var fromDir = path.join(templatePath, 'static');
	var staticFiles = fs.ls(fromDir, 3);
	staticFiles.forEach(function(fileName) {
		var toDir = fs.toDir( fileName.replace(fromDir, conf.outdir) );
		fs.mkPath(toDir);
		fs.copyFileSync(fileName, toDir);
	});

	__uniqueFilenames = null;

	info("publishing done.");
}
1217646
function makeClassname(prefix) {
  function classname () {
    var result = {},
        objects = {},
        resultString = "";

    function add (strings) {
      classname.each(strings.split(" "), function (string) {
        result[string] = !!string;
      });
    }

    classname.each([].slice.call(arguments), function (x) {
      switch (classname.getType(x)) {
        case "string":
        case "number":
          add(x);
          break;

        case "array":
          add(classname.apply(null, x));
          break;

        case "element":
          add(classname(x.className || ""));
          break;

        case "nodelist":
          add(classname.apply(null, [].slice.call(x)));
          break;

        case "jquery":
          add(classname.apply(null, x.get()));
          break;

        case "object":
          objects = classname.extend(objects, x);
          break;
      }
    });

    result = classname.extend(result, objects);

    classname.each(result, function (val, key) {
      if (val) {
        resultString += " " + (prefix || "") + key;
      }
    });

    return resultString.substr(1);
  }

  classname.setTo = function (elements) {
    var type = classname.getType(elements);

    if (type === "element") {
      elements = [elements];
    }

    if (type === "jquery") {
      elements = elements.get();
    }

    if (type === "nodelist") {
      elements = [].slice.call(elements);
    }

    return function () {
      var classNames = classname.apply(null, arguments);

      classname.each(elements, function (element) {
        element.className = classNames;
      });
    };
  };

  classname.each = function (arr, fn) {
    var type = classname.getType(arr);

    if (type === "array") {
      for (var i = 0; i < arr.length; i++) {
        fn(arr[i], i);
      }
    }

    if (type === "object") {
      for (var key in arr) {
        fn(arr[key], key);
      }
    }
  };

  classname.getType = function (x) {
    var type = Object.prototype.toString.call(x).slice(8, -1).toLowerCase();

    if (type === "object" && x.jquery) {
      return "jquery";
    }

    if (type.indexOf("element") > 1) {
      return "element";
    }

    return type;
  };

  classname.extend = function (obj1, obj2) {
    var result = {},
        objs = [obj1, obj2];

    classname.each(objs, function (obj) {
      classname.each(obj, function (val, key) {
        if (obj.hasOwnProperty(key)) {
          result[key] = val;
        }
      });
    });

    return result;
  }

  return classname
}
38653
function (dom, namespaceURI, qualifiedName, value) {
        /// <summary>Creates a new DOM attribute node.</summary>
        /// <param name="dom">DOM document used to create the attribute.</param>
        /// <param name="prefix" type="String">Namespace prefix.</param>
        /// <param name="namespaceURI" type="String">Namespace URI.</param>
        /// <returns>DOM attribute node for the namespace declaration.</returns>

        // ##### BEGIN: MODIFIED BY SAP
        // added usage of _createAttributeNS as fallback (see function above)
        var attribute =
            dom.createAttributeNS && dom.createAttributeNS(namespaceURI, qualifiedName) ||
            "createNode" in dom && dom.createNode(2, qualifiedName, namespaceURI || undefined) ||
            _createAttributeNS(namespaceURI, qualifiedName);
        // 

        attribute.value = value || "";
        return attribute;
    }
568828
void appendGoogRequiresTo(StringBuilder sb) {
    for (GoogRequire require : googRequires.values()) {
      // TODO(lukes): we need some namespace management here... though really we need namespace
      // management with all declarations... The problem is that a require could introduce a name
      // alias that conflicts with a symbol defined elsewhere in the file.
      require.writeTo(sb);
    }
  }
31924
function checkReference(references) {
            astUtils.getModifyingReferences(references).forEach(reference => {
                context.report({ node: reference.identifier, message: "'{{name}}' is a function.", data: { name: reference.identifier.name } });
            });
        }
104934
function ReferencedIdentifier(node, parent, scope, state) {
    var ref = state.letReferences[node.name];

    // not a part of our scope
    if (!ref) return;

    // this scope has a variable with the same name so it couldn't belong
    // to our let scope
    var localBinding = scope.getBindingIdentifier(node.name);
    if (localBinding && localBinding !== ref) return;

    state.closurify = true;
  }
50034
function (namespace, names){
    if (names){
      for (let i = 0, n = names.length; i < n; ++i){
        let typeName = names[i];
        if (namespace.names.hasOwnProperty(typeName)){
          this.names[typeName] = namespace.names[typeName];
        }
        else {
          throw new ReferenceError('import error: undefined type \'' + typeName + '\'');
        }
      }
    }
    else {
      // import *
      for (let typeName in namespace.names){
        if (namespace.names.hasOwnProperty(typeName)){
          this.names[typeName] = namespace.names[typeName];
        }
      }
    }
    return this;
  }
1286055
private boolean maybeUseNativeClassTemplateNames(JSDocInfo info) {
    // TODO(b/74253232): maybeGetNativeTypesOfBuiltin should also handle cases where a local type
    // declaration shadows a templatized native type.
    ImmutableList<TemplateType> nativeKeys = typeRegistry.maybeGetTemplateTypesOfBuiltin(fnName);
    // TODO(b/73386087): Make infoTemplateTypeNames.size() == nativeKeys.size() a
    // Preconditions check. It currently fails for "var symbol" in the externs.
    if (nativeKeys != null && info.getTemplateTypeNames().size() == nativeKeys.size()) {
      this.templateTypeNames = nativeKeys;
      return true;
    }
    return false;
  }
163873
function(prefix) {
    jst.global          = true;
    jst.globalTagPrefix = prefix || jst.tagPrefix;
    for (let tag of jst.tags) {
      let name = jst.globalTagPrefix + tag;
      let g = typeof global !== 'undefined' ? global : window;
      g[name] = function() {
        return jst[name].apply(this, arguments);
      };
    }
  }
146085
function(definition, client) {

  this.client = client;

  this.schema = null;

  this.ddlHelper = {
    tableName: null,
    pkAttrName: null,
    pkAutoIncrement: false,
    attrNamesToColNames: {},
    attrTypes: {},
    colNamesToAttrNames: {},
    colTypes: {},
    defaultValues: {},
    cqlCreateTable: null,
    indexes: {}
  };

  this._parseDefinition(definition);
}
1330586
function preProcessSymbols(symbols) {
			// Create treeName and modify module names
			symbols.forEach(oSymbol => {
				let sModuleClearName = oSymbol.name.replace(/^module:/, "");
				oSymbol.displayName = sModuleClearName;
				oSymbol.treeName = sModuleClearName.replace(/\//g, ".");
			});

			// Create missing - virtual namespaces
			symbols.forEach(oSymbol => {
				oSymbol.treeName.split(".").forEach((sPart, i, a) => {
					let sName = a.slice(0, (i + 1)).join(".");

					if (!symbols.find(o => o.treeName === sName)) {
						symbols.push({
							name: sName,
							displayName: sName,
							treeName: sName,
							lib: oSymbol.lib,
							kind: "namespace"
						});
					}
				});
			});

			// Discover parents
			symbols.forEach(oSymbol => {
				let aParent = oSymbol.treeName.split("."),
					sParent;

				// Extract parent name
				aParent.pop();
				sParent = aParent.join(".");

				// Mark parent
				if (symbols.find(({treeName}) => treeName === sParent)) {
					oSymbol.parent = sParent;
				}
			});

			// Attach children info
			symbols.forEach(oSymbol => {
				if (oSymbol.parent) {
					let oParent = symbols.find(({treeName}) => treeName === oSymbol.parent);

					if (!oParent.nodes) oParent.nodes = [];
					oParent.nodes.push({
						name: oSymbol.displayName,
						description: formatters._preProcessLinksInTextBlock(oSymbol.description),
						href: "#/api/" + encodeURIComponent(oSymbol.name)
					});
				}
			});

			// Clean list - keep file size down
			symbols.forEach(o => {
				delete o.treeName;
				delete o.parent;
			});
		}
1347057
function writeTable(browserPlatformType) {
  let compatNotes = collectCompatNotes();
  let output = writeTableHead(browserPlatformType);
  output += '<tbody>';
  for (let row of features) {
    let feature = Object.keys(row).map((k) => row[k])[0];
    let desc = '';
    if (feature.description) {
      let label = Object.keys(row)[0];
      // Basic support or unnested features need no prefixing
      if (label.indexOf('.') === -1) {
        desc += feature.description;
        // otherwise add a prefix so that we know where this belongs to (e.g. "parse: ISO 8601 format")
      } else {
        desc += `<code>${label.slice(0, label.lastIndexOf('.'))}</code>: ${feature.description}`;
      }
    } else {
      desc += `<code>${Object.keys(row)[0]}</code>`;
    }
    if (feature.mdn_url) {
      desc = `<a href="${feature.mdn_url}">${desc}</a>`;
    }
    output += `<tr><td>${desc}</td>`;
    output += `${writeSupportCells(feature.support, compatNotes, browserPlatformType)}</tr>`;
  }
  output += '</tbody></table></div>';
  return output;
}
25820
static boolean referencesThis(Node n) {
    if (n.isFunction()) {
      return referencesThis(NodeUtil.getFunctionParameters(n))
          || referencesThis(NodeUtil.getFunctionBody(n));
    } else {
      return has(n, Node::isThis, MATCH_ANYTHING_BUT_NON_ARROW_FUNCTION);
    }
  }
1143797
function (oChainObject) {
		function isBuiltInType(type) {
			return formatters._baseTypes.indexOf(type) >= 0;
		}

		/**
		 * Heuristically determining if there is a possibility the given input string
		 * to be a UI5 symbol
		 * @param {string} sName
		 * @returns {boolean}
		 */
		function possibleUI5Symbol(sName) {
			return /^[a-zA-Z][a-zA-Z.]*[a-zA-Z]$/.test(sName);
		}

		// Function is a copy from: LibraryInfo.js => LibraryInfo.prototype._getActualComponent => "match" inline method
		function matchComponent(sModuleName, sPattern) {
			sModuleName = sModuleName.toLowerCase();
			sPattern = sPattern.toLowerCase();
			return (
				sModuleName === sPattern
				|| sPattern.match(/\*$/) && sModuleName.indexOf(sPattern.slice(0,-1)) === 0 // simple prefix match
				|| sPattern.match(/\.\*$/) && sModuleName === sPattern.slice(0,-2) // directory pattern also matches directory itself
			);
		}

		/**
		 * Pre-processes the symbols list - creating virtual namespace records and attaching children list to namespace
		 * records.
		 * @param {object} symbols list
		 */
		function preProcessSymbols(symbols) {
			// Create treeName and modify module names
			symbols.forEach(oSymbol => {
				let sModuleClearName = oSymbol.name.replace(/^module:/, "");
				oSymbol.displayName = sModuleClearName;
				oSymbol.treeName = sModuleClearName.replace(/\//g, ".");
			});

			// Create missing - virtual namespaces
			symbols.forEach(oSymbol => {
				oSymbol.treeName.split(".").forEach((sPart, i, a) => {
					let sName = a.slice(0, (i + 1)).join(".");

					if (!symbols.find(o => o.treeName === sName)) {
						symbols.push({
							name: sName,
							displayName: sName,
							treeName: sName,
							lib: oSymbol.lib,
							kind: "namespace"
						});
					}
				});
			});

			// Discover parents
			symbols.forEach(oSymbol => {
				let aParent = oSymbol.treeName.split("."),
					sParent;

				// Extract parent name
				aParent.pop();
				sParent = aParent.join(".");

				// Mark parent
				if (symbols.find(({treeName}) => treeName === sParent)) {
					oSymbol.parent = sParent;
				}
			});

			// Attach children info
			symbols.forEach(oSymbol => {
				if (oSymbol.parent) {
					let oParent = symbols.find(({treeName}) => treeName === oSymbol.parent);

					if (!oParent.nodes) oParent.nodes = [];
					oParent.nodes.push({
						name: oSymbol.displayName,
						description: formatters._preProcessLinksInTextBlock(oSymbol.description),
						href: "#/api/" + encodeURIComponent(oSymbol.name)
					});
				}
			});

			// Clean list - keep file size down
			symbols.forEach(o => {
				delete o.treeName;
				delete o.parent;
			});
		}

		// Transform to object
		let oData = oChainObject.fileData;

		// Attach default component for the library if available
		if (oChainObject.defaultComponent) {
			oData.defaultComponent = oChainObject.defaultComponent;
		}

		formatters._oOwnLibrary = oData;

		// Pre process symbols
		preProcessSymbols(oData.symbols);

		// Apply formatter's and modify data as needed
		oData.symbols.forEach((oSymbol) => {

			// when the module name starts with the library name, then we apply the default component
			if (oSymbol.name.indexOf(oData.library) === 0) {
				oSymbol.component = oChainObject.defaultComponent;
			}

			// Attach symbol specific component if available (special cases)
			// Note: Last hit wins as there may be a more specific component pattern
			if (oChainObject.customSymbolComponents) {
				Object.keys(oChainObject.customSymbolComponents).forEach(sComponent => {
					if (matchComponent(oSymbol.name, sComponent)) {
						oSymbol.component = oChainObject.customSymbolComponents[sComponent];
					}
				});
			}

			// Attach symbol sample flag if available
			if (oChainObject.entitiesWithSamples) {
				oSymbol.hasSample = oChainObject.entitiesWithSamples.indexOf(oSymbol.name) >= 0;
			}

			// Apply settings to formatter object - needed until formatter's are rewritten
			formatters._sTopicId = oSymbol.name;
			formatters._oTopicData = oSymbol;

			// Format Page Title
			oSymbol.title = (oSymbol.abstract ? "abstract " : "") + oSymbol.kind + " " + oSymbol.displayName;
			oSymbol.subTitle = formatters.formatSubtitle(oSymbol.deprecated);

			// Constructor
			if (oSymbol.constructor) {
				let oConstructor = oSymbol.constructor;

				// Description
				if (oConstructor.description) {
					oConstructor.description = formatters.formatDescription(oConstructor.description);
				}

				// References
				formatters.modifyReferences(oSymbol, true);

				// Examples
				if (oConstructor.examples) {
					oConstructor.examples.forEach((oExample) => {
						oExample.data = formatters.formatExample(oExample.caption, oExample.text);

						// Keep file size in check
						if (oExample.caption) {
							delete oExample.caption;
						}
						if (oExample.text) {
							delete oExample.text;
						}
					});
				}

				// Code Example string
				oConstructor.codeExample = formatters.formatConstructor(oSymbol.name, oConstructor.parameters);

				// Parameters
				if (oConstructor.parameters) {
					oConstructor.parameters = methods.buildConstructorParameters(oConstructor.parameters);

					let aParameters = oConstructor.parameters;
					aParameters.forEach(oParameter => {

						// Types
						oParameter.types = [];
						if (oParameter.type) {
							let aTypes = oParameter.type.split("|");

							for (let i = 0; i < aTypes.length; i++) {
								oParameter.types.push({
									name: aTypes[i],
									linkEnabled: !isBuiltInType(aTypes[i])
								});
							}

							// Keep file size in check
							delete oParameter.type;
						}

						// Default value
						oParameter.defaultValue = formatters.formatDefaultValue(oParameter.defaultValue);

						// Description
						if (oParameter.description) {
							oParameter.description = formatters.formatDescription(oParameter.description);
						}

					})
				}

				// Throws
				if (oConstructor.throws) {
					oConstructor.throws.forEach(oThrows => {

						// Description
						if (oThrows.description) {
							oThrows.description = formatters.formatDescription(oThrows.description);
						}

						// Exception link enabled
						if (oThrows.type) {
							oThrows.linkEnabled = formatters.formatExceptionLink(oThrows.type);
						}

					});
				}
			}

			// Description
			if (oSymbol.description) {
				oSymbol.description = formatters.formatOverviewDescription(oSymbol.description, oSymbol.constructor.references);
			}

			// Deprecated
			if (oSymbol.deprecated) {
				oSymbol.deprecatedText = formatters.formatDeprecated(oSymbol.deprecated.since, oSymbol.deprecated.text);
				// Keep file size in check
				delete oSymbol.deprecated;
			}

			// Properties
			if (oSymbol.properties) {
				oSymbol.properties.forEach((oProperty) => {

					// Name
					oProperty.name = formatters.formatEntityName(oProperty.name, oSymbol.name, oProperty.static);

					// Description
					if (oProperty.deprecated) {
						oProperty.description = formatters.formatDescription(oProperty.description,
							oProperty.deprecated.text, oProperty.deprecated.since);
					} else {
						oProperty.description = formatters.formatDescription(oProperty.description);
					}

					// Link Enabled
					if (oSymbol.kind !== "enum" && !isBuiltInType(oProperty.type) && possibleUI5Symbol(oProperty.type)) {
						oProperty.linkEnabled = true;
						oProperty.href = "#/api/" + oProperty.type.replace("[]", "");
					}

					// Keep file size in check
					if (oProperty.static) {
						delete oProperty.static;
					}

					if (oSymbol.kind === "enum" || oProperty.type === "undefined") {
					    delete oProperty.type;
					}

				});
			}

			// UI5 Metadata
			if (oSymbol["ui5-metadata"]) {
				let oMeta = oSymbol["ui5-metadata"];

				// Properties
				if (oMeta.properties) {
					// Sort
					oMeta.properties.sort(function (a, b) {
						if (a.name < b.name) {
							return -1;
						} else if (a.name > b.name) {
							return 1;
						} else {
							return 0;
						}
					});

					// Pre-process
					oMeta.properties.forEach((oProperty) => {
						// Name
						oProperty.name = formatters.formatEntityName(oProperty.name, oSymbol.name, oProperty.static);

						// Description
						oProperty.description = formatters.formatDescriptionSince(oProperty.description, oProperty.since);

						// Link Enabled
						if (!isBuiltInType(oProperty.type)) {
							oProperty.linkEnabled = true;
						}

						// Default value
						oProperty.defaultValue = formatters.formatDefaultValue(oProperty.defaultValue);

						// Deprecated
						if (oProperty.deprecated) {
							oProperty.deprecatedText = formatters.formatDeprecated(oProperty.deprecated.since,
								oProperty.deprecated.text);

							// Keep file size in check
							delete oProperty.deprecated;
						}
					});
				}

				// Aggregations
				if (oMeta.aggregations) {
					// Sort
					oMeta.aggregations.sort(function (a, b) {
						if (a.name < b.name) {
							return -1;
						} else if (a.name > b.name) {
							return 1;
						} else {
							return 0;
						}
					});

					// Pre-process
					oMeta.aggregations.forEach((oAggregation) => {
						// Link Enabled
						if (!isBuiltInType(oAggregation.type)) {
							oAggregation.linkEnabled = true;
						}

						// Description
						if (oAggregation.deprecated) {
							oAggregation.description = formatters.formatDescription(oAggregation.description,
								oAggregation.deprecated.text, oAggregation.deprecated.since);
						} else {
							oAggregation.description = formatters.formatDescription(oAggregation.description);
						}

						// Link enabled
						oAggregation.linkEnabled = !isBuiltInType(oAggregation.type);
					});
				}

				// Associations

				if (oMeta.associations) {
					// Sort
					oMeta.associations.sort(function (a, b) {
						if (a.name < b.name) {
							return -1;
						} else if (a.name > b.name) {
							return 1;
						} else {
							return 0;
						}
					});

					// Pre-process
					oMeta.associations.forEach((oAssociation) => {
						// Link Enabled
						if (!isBuiltInType(oAssociation.type)) {
							oAssociation.linkEnabled = true;
						}

						// Description
						if (oAssociation.deprecated) {
							oAssociation.description = formatters.formatDescription(oAssociation.description,
								oAssociation.deprecated.text, oAssociation.deprecated.since);
						} else {
							oAssociation.description = formatters.formatDescription(oAssociation.description);
						}
					});
				}

				// Events
				if (oMeta.events) {
					// We don't need event's data from the UI5-metadata for now. Keep file size in check
					delete oMeta.events;
				}

				// Special Settings
				if (oMeta.specialSettings) {
					oMeta.specialSettings.forEach(oSetting => {

						// Link Enabled
						if (!isBuiltInType(oSetting.type)) {
							oSetting.linkEnabled = true;
						}

						// Description
						if (oSetting.deprecated) {
							oSetting.description = formatters.formatDescription(oSetting.description,
								oSetting.deprecated.text, oSetting.deprecated.since);
						} else {
							oSetting.description = formatters.formatDescription(oSetting.description);
						}

					});
				}

				// Annotations
				if (oMeta.annotations) {
					oMeta.annotations.forEach(oAnnotation => {

						// Description
						oAnnotation.description = formatters.formatAnnotationDescription(oAnnotation.description,
							oAnnotation.since);

						// Namespace
						oAnnotation.namespaceText = oAnnotation.namespace;
						oAnnotation.namespace = formatters.formatAnnotationNamespace(oAnnotation.namespace);

						// Target
						oAnnotation.target = formatters.formatAnnotationTarget(oAnnotation.target);

						// Applies to
						oAnnotation.appliesTo = formatters.formatAnnotationTarget(oAnnotation.appliesTo);

					});
				}

			}

			if (oSymbol.events) {

				// Pre-process events
				methods.buildEventsModel(oSymbol.events);

				oSymbol.events.forEach(oEvent => {

					// Description
					if (oEvent.description) {
						oEvent.description = formatters.formatDescriptionSince(oEvent.description, oEvent.since);
					}

					// Deprecated
					if (oEvent.deprecated) {
						oEvent.deprecatedText = formatters.formatEventDeprecated(oEvent.deprecated.since,
							oEvent.deprecated.text);
					}

					// Parameters
					if (oEvent.parameters && Array.isArray(oEvent.parameters)) {
						oEvent.parameters.forEach(oParameter => {

							// Link Enabled
							if (!isBuiltInType(oParameter.type)) {
								oParameter.linkEnabled = true;
							}

							// Description
							if (oParameter.deprecated) {
								oParameter.description = formatters.formatDescription(oParameter.description,
									oParameter.deprecated.text, oParameter.deprecated.since);
							} else {
								oParameter.description = formatters.formatDescription(oParameter.description);
							}

						});
					}

				});

			}

			// Methods
			if (oSymbol.methods) {

				// Pre-process methods
				methods.buildMethodsModel(oSymbol.methods);

				oSymbol.methods.forEach(oMethod => {

					// Name and link
					if (oMethod.name) {
						oMethod.name = formatters.formatEntityName(oMethod.name, oSymbol.name, oMethod.static);

						// Link
						oMethod.href = "#/api/" + encodeURIComponent(oSymbol.name) +
							"/methods/" + encodeURIComponent(oMethod.name);
					}

					formatters.formatReferencesInDescription(oMethod);

					// Description
					if (oMethod.description) {
						oMethod.description = formatters.formatDescription(oMethod.description);
					}

					// Examples
					oMethod.examples && oMethod.examples.forEach(oExample => {
						oExample = formatters.formatExample(oExample.caption, oExample.text);
					});

					// Deprecated
					if (oMethod.deprecated) {
						oMethod.deprecatedText = formatters.formatEventDeprecated(oMethod.deprecated.since,
							oMethod.deprecated.text);
					}

					// Code example
					oMethod.code = formatters.formatMethodCode(oMethod.name, oMethod.parameters, oMethod.returnValue);

					// Parameters
					if (oMethod.parameters) {
						oMethod.parameters.forEach(oParameter => {

							// Types
							if (oParameter.types) {
								oParameter.types.forEach(oType => {

									// Link Enabled
									if (!isBuiltInType(oType.value) && possibleUI5Symbol(oType.value)) {
										oType.linkEnabled = true;
										oType.href = "#/api/" + oType.value.replace("[]", "");
									}

								});
							}

							// Default value
							oParameter.defaultValue = formatters.formatDefaultValue(oParameter.defaultValue);

							// Description
							if (oParameter.deprecated) {
								oParameter.description = formatters.formatDescription(oParameter.description,
									oParameter.deprecated.text, oParameter.deprecated.since);
							} else {
								oParameter.description = formatters.formatDescription(oParameter.description);
							}

						});
					}

					// Return value
					if (oMethod.returnValue) {

						// Description
						oMethod.returnValue.description = formatters.formatDescription(oMethod.returnValue.description);

						// Types
						if (oMethod.returnValue.types) {
							oMethod.returnValue.types.forEach(oType => {

								// Link Enabled
								if (!isBuiltInType(oType.value)) {
									oType.href = "#/api/" + encodeURIComponent(oType.value.replace("[]", ""));
									oType.linkEnabled = true;
								}

							});
						}

					}

					// Throws
					if (oMethod.throws) {
						oMethod.throws.forEach(oThrows => {

							// Description
							if (oThrows.description) {
								oThrows.description = formatters.formatDescription(oThrows.description);
							}

							// Exception link enabled
							if (oThrows.type) {
								oThrows.linkEnabled = formatters.formatExceptionLink(oThrows.type);
							}

						});
					}

					// Examples
					if (oMethod.examples) {
						oMethod.examples.forEach((oExample) => {
							oExample.data = formatters.formatExample(oExample.caption, oExample.text);

							// Keep file size in check
							if (oExample.caption) {
								delete oExample.caption;
							}
							if (oExample.text) {
								delete oExample.text;
							}
						});

					}


				});
			}

			// Formatting namespaces, functions and enums, which may contain examples
			// or references with links to process them similar to methods and constructors of classes

			if (oSymbol.kind !== "class") {

				if (oSymbol.examples) {
					oSymbol.examples.forEach((oExample) => {
						oExample.data = formatters.formatExample(oExample.caption, oExample.text);
						// Keep file size in check
						if (oExample.caption) {
							delete oExample.caption;
						}
						if (oExample.text) {
							delete oExample.text;
						}
					});
				}

				if (oSymbol.references) {
					formatters.modifyReferences(oSymbol);
					formatters.formatReferencesInDescription(oSymbol);
				}

				// Description
				if (oSymbol.description) {
					oSymbol.description = formatters.formatDescription(oSymbol.description);
				}
			}
		});

		oChainObject.parsedData = oData;

		return oChainObject;
	}