Increments the reference amount of a node's definition unless the
 definition is frozen.

 @param [RubyLint::AST::Node] node
972318
def increment_reference_amount(node)
      definition = definition_for_node(node)

      if definition and !definition.frozen?
        definition.reference_amount += 1
      end
    end
511770
def iterate(node)
      return unless node.is_a?(AST::Node)

      before    = :"on_#{node.type}"
      after     = :"after_#{node.type}"
      skip_node = catch :skip_child_nodes do
        execute_callback(before, node)
      end

      if skip_node != node
        node.children.each do |child|
          iterate(child) if child.is_a?(AST::Node)
        end
      end

      execute_callback(after, node)
    end
255208
def on_def(node)
      receiver = nil

      if node.type == :defs
        receiver = evaluate_node(node.children[0])
      end

      builder = DefinitionBuilder::RubyMethod.new(
        node,
        self,
        :type       => @method_type,
        :receiver   => receiver,
        :visibility => @visibility
      )

      definition = builder.build

      builder.scope.add_definition(definition)

      associate_node(node, definition)

      buffer_docstring_tags(node)

      if docstring_tags and docstring_tags.return_tag
        assign_return_value_from_tag(
          docstring_tags.return_tag,
          definition
        )
      end

      push_scope(definition)
    end
539135
def __visit_target(self, node):
    

    if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
      self.__add_variable(node.id)
    elif isinstance(node, (ast.Tuple, ast.List)):
      [self.__visit_target(x) for x in node.elts]
458288
def increment(self, key, value=1):
        
        self._store.increment(self.tagged_item_key(key), value)
492045
def lock(nodes, depth = 'infinity')
      properties = {}

      nodes.each do |node|
        next unless node.is_a? Nokogiri::XML::Element

        properties[node.name.to_sym] = node
      end

      create_blank_file unless exists?

      create_lock properties, depth
      fetch_lock_info
    end
460000
def parse(node)
      node.attributes.each do |key, value|
        case key
        when 'ref'
          @reference = Coordinates.parser_coordinates_range(value.value.to_s)
        when 'si'
          @string_index = value.value.to_i
        when 't'
          @type = value.value.to_s
        end
      end

      @value = node.text unless node.text.empty?
      self
    end
849557
def assign_variable(type, name, value, node)
      scope    = assignment_scope(type)
      variable = scope.lookup(type, name)

      # If there's already a variable we'll just update it.
      if variable
        variable.reference_amount += 1

        # `value` is not for conditional assignments as those are handled
        # manually.
        variable.value = value if value
      else
        variable = Definition::RubyObject.new(
          :type             => type,
          :name             => name,
          :value            => value,
          :instance_type    => :instance,
          :reference_amount => 0,
          :line             => node.line,
          :column           => node.column,
          :file             => node.file
        )
      end

      buffer_assignment_value(value)

      # Primarily used by #after_send to support variable assignments as method
      # call arguments.
      if value and !value_stack.empty?
        value_stack.push(variable.value)
      end

      add_variable(variable, scope)
    end
1329234
def increment_lineno(node, n=1):
    
    for node in zip((node,), walk(node)):
        if 'lineno' in node._attributes:
            node.lineno = getattr(node, 'lineno', 0) + n
145892
def _eval_num(self, node):
        
        if self.floats:
            return node.n
        else:
            return int(node.n)
933813
def on_block(node)
      builder    = DefinitionBuilder::RubyBlock.new(node, self)
      definition = builder.build

      associate_node(node, definition)

      push_scope(definition)
    end
488645
def prepend_child(node)
      raise "argument to << must be a String or Ox::Node." unless node.is_a?(String) or node.is_a?(Node)
      @nodes = [] if !instance_variable_defined?(:@nodes) or @nodes.nil?
      @nodes.unshift(node)
      self
    end
1182422
function isInRange(node, reference) {
    const or = node.range;
    const ir = reference.identifier.range;

    return or[0] <= ir[0] && ir[1] <= or[1];
}
156521
def ct_increment(increment = 1)
      params = { ct: {} }
      params[:ct][:increment] = increment
      @requester.put(url: "#{@api_url}/state", params: params)
    end
1174621
function addNumeratorsTogether(node) {
  const newNode = clone(node);

  newNode.args[0] = Node.Creator.constant(newNode.args[0].eval());
  return Node.Status.nodeChanged(
    ChangeTypes.ADD_NUMERATORS, node, newNode);
}
910128
private T retain0(T instance, final int increment, final int rawIncrement) {
        int oldRef = updater().getAndAdd(instance, rawIncrement);
        if (oldRef != 2 && oldRef != 4 && (oldRef & 1) != 0) {
            throw new IllegalReferenceCountException(0, increment);
        }
        // don't pass 0!
        if ((oldRef <= 0 && oldRef + rawIncrement >= 0)
                || (oldRef >= 0 && oldRef + rawIncrement < oldRef)) {
            // overflow case
            updater().getAndAdd(instance, -rawIncrement);
            throw new IllegalReferenceCountException(realRefCnt(oldRef), increment);
        }
        return instance;
    }
131013
def apply(self, node):
        
        new_node = self.run(node)
        return self.update, new_node