Tries to return a useful string identificator of the given node

@param {node} node
@returns Identificator of the node
@type {String}
493270
function _reportNode(node) {
  if (node.id) {
    return "id: " + node.id;
  } else if (node.label) {
    return "label: " + node.label;
  } else if (node.value) {
    return "value: " + node.value;
  } else if (node.hasAttributes()) {
    var attrs = "node attributes: ";
    for (var i = node.attributes.length - 1; i >= 0; i--) {
      attrs += node.attributes[i].name + "->" + node.attributes[i].value + ";";
    }
    return attrs;
  } else {
    return "anonymous node";
  }
}
99487
function getNodejsId(text, repetition) {
  text = text.replace(/[^a-z0-9]+/g, '_');
  text = text.replace(/^_+|_+$/, '');
  text = text.replace(/^([^a-z])/, '_$1');

  // If no repetition, or if the repetition is 0 then ignore. Otherwise append '_' and the number.
  // An example may be found here: http://nodejs.org/api/domain.html#domain_example_1
  if (repetition) {
    text += '_' + repetition;
  }

  return text;
}
233510
function getForInVariableSymbol(node) {
            var initializer = node.initializer;
            if (initializer.kind === 219 /* VariableDeclarationList */) {
                var variable = initializer.declarations[0];
                if (variable && !ts.isBindingPattern(variable.name)) {
                    return getSymbolOfNode(variable);
                }
            }
            else if (initializer.kind === 69 /* Identifier */) {
                return getResolvedSymbol(initializer);
            }
            return undefined;
        }
1374515
def branch(self, node, **kwargs):
        """"""

        return _Identifiers(self.compiler, node, self, **kwargs)
1146475
function(node) {
    if (node.nodeType !== 1) {
      // Not a DOMElement, therefore not a React component
      return false;
    }
    var id = ReactMount.getID(node);
    return id ? id.charAt(0) === SEPARATOR : false;
  }
1126158
function getDeclarationName(node) {
            if (node.name) {
                if (ts.isAmbientModule(node)) {
                    return ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + node.name.text + "\"";
                }
                if (node.name.kind === 140 /* ComputedPropertyName */) {
                    var nameExpression = node.name.expression;
                    // treat computed property names where expression is string/numeric literal as just string/numeric literal
                    if (ts.isStringOrNumericLiteral(nameExpression.kind)) {
                        return nameExpression.text;
                    }
                    ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression));
                    return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text);
                }
                return node.name.text;
            }
            switch (node.kind) {
                case 148 /* Constructor */:
                    return "__constructor";
                case 156 /* FunctionType */:
                case 151 /* CallSignature */:
                    return "__call";
                case 157 /* ConstructorType */:
                case 152 /* ConstructSignature */:
                    return "__new";
                case 153 /* IndexSignature */:
                    return "__index";
                case 236 /* ExportDeclaration */:
                    return "__export";
                case 235 /* ExportAssignment */:
                    return node.isExportEquals ? "export=" : "default";
                case 187 /* BinaryExpression */:
                    switch (ts.getSpecialPropertyAssignmentKind(node)) {
                        case 2 /* ModuleExports */:
                            // module.exports = ...
                            return "export=";
                        case 1 /* ExportsProperty */:
                        case 4 /* ThisProperty */:
                            // exports.x = ... or this.y = ...
                            return node.left.name.text;
                        case 3 /* PrototypeProperty */:
                            // className.prototype.methodName = ...
                            return node.left.expression.name.text;
                    }
                    ts.Debug.fail("Unknown binary declaration kind");
                    break;
                case 220 /* FunctionDeclaration */:
                case 221 /* ClassDeclaration */:
                    return node.flags & 512 /* Default */ ? "default" : undefined;
                case 269 /* JSDocFunctionType */:
                    return ts.isJSDocConstructSignature(node) ? "__new" : "__call";
                case 142 /* Parameter */:
                    // Parameters with names are handled at the top of this function.  Parameters
                    // without names can only come from JSDocFunctionTypes.
                    ts.Debug.assert(node.parent.kind === 269 /* JSDocFunctionType */);
                    var functionType = node.parent;
                    var index = ts.indexOf(functionType.parameters, node);
                    return "p" + index;
                case 279 /* JSDocTypedefTag */:
                    var parentNode = node.parent && node.parent.parent;
                    var nameFromParentNode = void 0;
                    if (parentNode && parentNode.kind === 200 /* VariableStatement */) {
                        if (parentNode.declarationList.declarations.length > 0) {
                            var nameIdentifier = parentNode.declarationList.declarations[0].name;
                            if (nameIdentifier.kind === 69 /* Identifier */) {
                                nameFromParentNode = nameIdentifier.text;
                            }
                        }
                    }
                    return nameFromParentNode;
            }
        }
417278
function findSymbolName (node) {
  const math = getMath()
  let n = node

  while (n) {
    if (math.isSymbolNode(n)) {
      return n.name
    }
    n = n.object
  }

  return null
}
1148479
function parseNode(line) {
  current = {
    is : 'NODE',
    type : 'NODE',
    id : line.substr(10, 10).trim().toLowerCase(),
    initialStorage : line.substr(20, 10).trim(),
    areaCapfactor : line.substr(30, 10).trim(),
    endingStorage : line.substr(40, 10).trim()
  };
}
1374205
function getElementTag(node) {
        if (node.openingElement && t.isJSXIdentifier(node.openingElement.name)) {
            return node.openingElement.name.name;
        } else {
            error(node.openingElement, "Unable to parse opening tag.");
        }
    }
646174
function getLeftmostName(node) {
	while ( node.type === Syntax.MemberExpression ) {
		node = node.object;
	}
	if ( node.type === Syntax.Identifier ) {
		return node.name;
	}
	// return undefined;
}
1138093
function definition(node) {
  var content = uri(node.url)

  if (node.title) {
    content += space + title(node.title)
  }

  return (
    leftSquareBracket +
    (node.label || node.identifier) +
    rightSquareBracket +
    colon +
    space +
    content
  )
}
902829
def visit_FunctionDef(self, node):
        
        if (len(node.body) == 1 and
                isinstance(node.body[0], (ast.Call, ast.Return))):
            ids = self.gather(Identifiers, node.body[0])
            # FIXME : It mark "not inlinable" def foo(foo): return foo
            if node.name not in ids:
                self.result[node.name] = copy.deepcopy(node)
184961
function getEntityNameForExtendingInterface(node) {
            switch (node.kind) {
                case 69 /* Identifier */:
                case 172 /* PropertyAccessExpression */:
                    return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
                case 194 /* ExpressionWithTypeArguments */:
                    ts.Debug.assert(ts.isEntityNameExpression(node.expression));
                    return node.expression;
                default:
                    return undefined;
            }
        }
1043510
function( node ) {
			var out = '',
				j = 0;

			if(node.tagName && this.excludeTags.indexOf( node.tagName.toLowerCase() ) > -1){
				return out;
			}

			// if node is a text node get its text
			if(node.nodeType && node.nodeType === 3){
				out += modules.domUtils.getElementText( node );
			}

			// get the text of the child nodes
			if(node.childNodes && node.childNodes.length > 0){
				for (j = 0; j < node.childNodes.length; j++) {
					var text = this.walkTreeForText( node.childNodes[j] );
					if(text !== undefined){
						out += text;
					}
				}
			}

			// if it's a block level tag add an additional space at the end
			if(node.tagName && this.blockLevelTags.indexOf( node.tagName.toLowerCase() ) !== -1){
				out += ' ';
			}

			return (out === '')? undefined : out ;
		}
520555
function _lookupByNodeIdentifier(nodeIdentifier, timeoutMs) {
        // if the address is cached, return that
        if (cachedNodes[nodeIdentifier]) {
            return rx.of({ destination64: cachedNodes[nodeIdentifier]});
        }

        if (debug) {
            console.log("Looking up", nodeIdentifier);
        }

        return _localCommand("DN", timeoutMs, nodeIdentifier).pipe(
            rx.operators.catchError(function() {
                return rx.throwError(new Error("Node not found"));
            }),
            rx.operators.map(_extractDestination64),
            rx.operators.tap(function(address64) {
                cachedNodes[nodeIdentifier] = address64;
            }),
            rx.operators.map(function(address64) {
                return { destination64: address64 };
            })
        );
    }
90126
function tryGetName(node) {
            if (node.kind === 225 /* ModuleDeclaration */) {
                return getModuleName(node);
            }
            var decl = node;
            if (decl.name) {
                return ts.getPropertyNameForPropertyNameNode(decl.name);
            }
            switch (node.kind) {
                case 179 /* FunctionExpression */:
                case 180 /* ArrowFunction */:
                case 192 /* ClassExpression */:
                    return getFunctionOrClassName(node);
                case 279 /* JSDocTypedefTag */:
                    return getJSDocTypedefTagName(node);
                default:
                    return undefined;
            }
        }
1331728
function getFunctionName (node) {
  if (node.type !== "CallExpression") {
    return null;
  }
  var callee = node.callee;
  if (callee && callee.type === "Identifier") {
    return callee.name;
  }
  return callee.property ? (callee.property.name || callee.property.value) : null;
}