return an astroid.While node as string
189807
def visit_while(self, node):
        """"""
        whiles = "while %s:\n%s" % (node.test.accept(self), self._stmt_list(node.body))
        if node.orelse:
            whiles = "%s\nelse:\n%s" % (whiles, self._stmt_list(node.orelse))
        return whiles
390491
def infer_len(node, context=None):
    
    call = arguments.CallSite.from_call(node)
    if call.keyword_arguments:
        raise UseInferenceDefault("TypeError: len() must take no keyword arguments")
    if len(call.positional_arguments) != 1:
        raise UseInferenceDefault(
            "TypeError: len() must take exactly one argument "
            "({len}) given".format(len=len(call.positional_arguments))
        )
    [argument_node] = call.positional_arguments
    try:
        return nodes.Const(helpers.object_len(argument_node, context=context))
    except (AstroidTypeError, InferenceError) as exc:
        raise UseInferenceDefault(str(exc)) from exc
1296728
function WhileStatement(node, print) {
  this.keyword("while");
  this.push("(");
  print.plain(node.test);
  this.push(")");
  print.block(node.body);
}
1236206
def visit_FunctionBody(self, node):
        """"""
        for child in node.children:
            return_value = self.visit(child)

            if isinstance(child, ReturnStatement):
                return return_value

            if isinstance(child, (IfStatement, WhileStatement)):
                if return_value is not None:
                    return return_value

        return NoneType()
983751
def visit_Tuple(self, node: AST, dfltChaining: bool = True) -> str:
        """"""
        elems = (self.visit(elt) for elt in node.elts)
        return f"({', '.join(elems)}{')' if len(node.elts) != 1 else ',)'}"
808612
def get_node(self, goid, goobj):
        """"""
        # pydot.Node.objdict holds this information. pydot.Node.objdict['name']
        return pydot.Node(
            self.get_node_text(goid, goobj),
            shape="box",
            style="rounded, filled",
            fillcolor=self.go2color.get(goid, "white"),
            color=self.objcolor.get_bordercolor(goid))
1123801
def infer_str(node, context=None):
    
    call = arguments.CallSite.from_call(node)
    if call.keyword_arguments:
        raise UseInferenceDefault("TypeError: str() must take no keyword arguments")
    try:
        return nodes.Const("")
    except (AstroidTypeError, InferenceError) as exc:
        raise UseInferenceDefault(str(exc)) from exc
1098646
def _looks_like_functools_member(node, member):
    """"""
    if isinstance(node.func, astroid.Name):
        return node.func.name == member
    elif isinstance(node.func, astroid.Attribute):
        return (
            node.func.attrname == member
            and isinstance(node.func.expr, astroid.Name)
            and node.func.expr.name == "functools"
        )
154346
def getdata(self, tree, location, force_string=False):
        """"""
        found = tree.xpath('%s/text()' % location)
        if not found:
            return None
        else:
            data = found[0]
        if force_string:
            return data
        if data == 'True':
            return True
        elif data == 'False':
            return False
        else:
            try:
                return int(data)
            except ValueError:
                try:
                    return float(data)
                except ValueError:
                    # It's a string
                    return data
669232
def uid_something_colon(self, node):
        
        node.op_pos = [
            NodeWithPosition(node.uid, (node.first_line, node.first_col))
        ]
        position = (node.body[0].first_line, node.body[0].first_col)
        last, first = self.operators[':'].find_previous(position)
        node.op_pos.append(NodeWithPosition(last, first))
        return last
341837
def select(self, node):
        
        child = self.translate(node.child)
        return '[.${op}_{{{conditions}}}$ {child} ]'\
            .format(op=latex_operator[node.operator],
                    conditions=node.conditions, child=child)
180822
def _do_pi(self, node):
        '''
        '''
        if not _in_subset(self.subset, node): return
        W = self.write
        if self.documentOrder == _GreaterElement: W('\n')
        W('<?')
        W(node.nodeName)
        s = node.data
        if s:
            W(' ')
            W(s)
        W('?>')
        if self.documentOrder == _LesserElement: W('\n')
823029
def innertext(node):
    """"""
    if not len(node):
        return node.text

    return (node.text or '') + ''.join([etree.tostring(c) for c in node]) + (node.tail or '')
487569
def visit_Name(self, node: AST, dfltChaining: bool = True) -> str:
        """"""
        return node.id
1366736
def while_node(node, indent)
      # While we have a branch that meets the condition, generate code for the
      # children related to that specific branch
      buffer_eval "while #{node[@value]}"

      # Evaluate child nodes
      node[@children].each do |child|
        root child, indent
      end

      #End
      buffer_eval 'end'
    end
416217
def visit_Set(self, node: AST, dfltChaining: bool = True) -> str:
        """"""
        return '{' + ', '.join([self.visit(elt) for elt in node.elts]) + '}'
422994
function stringifyNode(node)
{
	var result = "<"+node.nodeName;
	var numAttrs = node.attrs.length;
	
	for (var i=0; i<numAttrs; i++)
	{
		result += " "+ node.attrs[i].name +'="'+ node.attrs[i].value +'"';
	}
	
	result += ">";
	
	return result;
}