function resolveFullyQuantifiedName(node) {
	// The missing part is on the left side. The right side is clear.
	// We would eiter ways resolve to the same leftmost token.
	let leftMostName = getLeftmostName(node);
	let originalName = getObjectName(node) || "";
	const currentScope = getEnclosingVariableScope(node);

	if (!currentScope) {
		return "";
	}

	while (leftMostName) {
		const curVar = currentScope.set.get(leftMostName);

		if (!curVar) {
			break;
		}

		if ( !isVarDestructuring(curVar) ) {
			// Not a destructuring
			return getResolvedName(originalName, leftMostName);
		}

		const potentialRenaming = checkVarRenaming(curVar);
		if (potentialRenaming) {
			let renamedChunks = originalName.split(".");
			renamedChunks = getResolvedName( originalName, renamedChunks[0] ).split(".");

			// when getResolvedName() was not able to resolve the renaming of a variable
			// with currentModule.localNames[].path i.e. in "chained" destructuring, where
			// the variable is not within localNames registry
			if ( potentialRenaming.renamed === renamedChunks[0] ) { // Checks for direct renaming
				renamedChunks[0] = potentialRenaming.original;
			}
			// Considers the 'path' if it differs from the original name i.e. there's some namespace before it
			if ( potentialRenaming.original === renamedChunks[0] && potentialRenaming.path !== potentialRenaming.original ) {
				renamedChunks[0] = potentialRenaming.path;
			}

			originalName = renamedChunks.join(".");
		}

		const writeExpr = curVar.references.filter((ref) => ref.writeExpr);

		// The same case as variable.defs- we're not able to determine the correct chain in case of multiple writeExpr
		if (writeExpr.length !== 1) {
			// writeExpr.length === 0 means an function argument and then we need
			// just to return the already build originalName
			return writeExpr.length === 0 ? originalName : "";
		}

		const writeExprNode = writeExpr[0].writeExpr;

		if ( writeExprNode.type === Syntax.MemberExpression && !writeExprNode.computed && writeExprNode.object.type === Syntax.Identifier ) {
			leftMostName = writeExprNode.object.name;

		} else if (writeExprNode.type === Syntax.MemberExpression && writeExprNode.object.type === Syntax.MemberExpression) { // Standalone variable without leading dot notation namespace
			leftMostName = getResolvedObjectName(writeExprNode);

		} else if (writeExprNode.type === Syntax.Identifier) {
			leftMostName = writeExprNode.name;

		} else {
			leftMostName = "";
		}

		if (leftMostName) {
			originalName = leftMostName + "." + originalName;
		}
	}

	return originalName;
}
Builds the fully quantified name when there's a destructuring of a variable

@param {Node} node
@returns {string}