Adds the new assign or name declaration after the original assign or name declaration
347399
private static void addAfter(Node originalLvalue, Node newLvalue, Node newRvalue) {
    Node parent = originalLvalue.getParent();
    if (parent.isAssign()) {
      // create `(<originalLvalue = ...>, <newLvalue = newRvalue>)`
      Node newAssign = IR.assign(newLvalue, newRvalue).srcref(parent);
      Node newComma = new Node(Token.COMMA, newAssign);
      parent.replaceWith(newComma);
      newComma.addChildToFront(parent);
      return;
    }
    // This must have been in a var/let/const.
    if (newLvalue.isDestructuringPattern()) {
      newLvalue = new Node(Token.DESTRUCTURING_LHS, newLvalue, newRvalue).srcref(parent);
    } else {
      newLvalue.addChildToBack(newRvalue);
    }
    Node declaration = parent.isDestructuringLhs() ? originalLvalue.getGrandparent() : parent;
    checkState(NodeUtil.isNameDeclaration(declaration), declaration);
    if (NodeUtil.isStatementParent(declaration.getParent())) {
      // `const {} = originalRvalue; const newLvalue = newRvalue;`
      // create an entirely new statement
      Node newDeclaration = new Node(declaration.getToken()).srcref(declaration);
      newDeclaration.addChildToBack(newLvalue);
      declaration.getParent().addChildAfter(newDeclaration, declaration);
    } else {
      // `const {} = originalRvalue, newLvalue = newRvalue;`
      // The Normalize pass tries to ensure name declarations are always in statement blocks, but
      // currently has not implemented normalization for `for (let x = 0; ...`
      // so we can't add a new statement
      declaration.addChildToBack(newLvalue);
    }
  }
1067591
def modify(name, old_value, new_value)
      @attributes[name] = new_value
      if @modifications && (old_value != new_value)
        original = @modifications[name].first if @modifications[name]
        @modifications[name] = [ (original || old_value), new_value ]
      end
    end
1158873
def add(self, outputfilename, outputtemplate, inputfilename=None, inputtemplate=None):
        """"""
        if isinstance(outputtemplate,OutputTemplate):
            outputtemplate = outputtemplate.id
        if isinstance(inputtemplate,InputTemplate):
            inputtemplate = inputtemplate.id
        if outputfilename in self:
            outputtemplate, inputfiles = self[outputfilename]
            if inputfilename and inputtemplate:
                inputfiles[inputfilename] = inputtemplate
        else:
            if inputfilename and inputtemplate:
                self[outputfilename] = (outputtemplate, {inputfilename: inputtemplate})
            else:
                self[outputfilename] = (outputtemplate, {})
347370
function add(css, name) {
        if (name) { byName[name] = css; }
        else { remainder.push(css); }
        needsInject = true;
      }
803564
def _add_assignment_methods(name, element_method, opts)
      assign_method = opts.delete(:assign_method)
      return unless assign_method

      define_method("#{name}=") do |value|
        return assign_method.call(name, self, value) if assign_method.is_a?(Proc)

        send(element_method).send(assign_method, value)
      end
    end
110065
def add_type(self, new_name, orig_names):
        
        self._dlog("adding a type '{}'".format(new_name))
        # TODO do we allow clobbering of types???
        res = copy.copy(orig_names)
        resolved_names = self._resolve_name(res[-1])
        if resolved_names is not None:
            res.pop()
            res += resolved_names

        self._curr_scope["types"][new_name] = res
442333
def add_to_assignees(self, *assignees):
        
        assert all(isinstance(element, (github.NamedUser.NamedUser, str, unicode)) for element in assignees), assignees
        post_parameters = {"assignees": [assignee.login if isinstance(assignee, github.NamedUser.NamedUser) else assignee for assignee in assignees]}
        headers, data = self._requester.requestJsonAndCheck(
            "POST",
            self.url + "/assignees",
            input=post_parameters
        )
        self._useAttributes(data)
919353
def add_attr(self, name, value):
        """"""
        setattr(self, name, value)
        self.attrs.append(name)
686186
def visit_augassign(self, node, parent):
        """"""
        newnode = nodes.AugAssign(
            self._bin_op_classes[type(node.op)] + "=",
            node.lineno,
            node.col_offset,
            parent,
        )
        newnode.postinit(
            self.visit(node.target, newnode), self.visit(node.value, newnode)
        )
        return newnode
589197
private void addAliasDeclarationNodes() {
    for (Entry<String, StringInfo> entry : stringInfoMap.entrySet()) {
      StringInfo info = entry.getValue();
      if (!info.isAliased) {
        continue;
      }
      String alias = info.getVariableName(entry.getKey());
      Node var = IR.var(IR.name(alias), IR.string(entry.getKey()));
      var.useSourceInfoFromForTree(info.parentForNewVarDecl);
      if (info.siblingToInsertVarDeclBefore == null) {
        info.parentForNewVarDecl.addChildToFront(var);
      } else {
        info.parentForNewVarDecl.addChildBefore(
            var, info.siblingToInsertVarDeclBefore);
      }
      compiler.reportChangeToEnclosingScope(var);
    }
  }
338238
public void add(ServiceReference<D> declarationSRef) {
        D declaration = getDeclaration(declarationSRef);
        boolean matchFilter = declarationFilter.matches(declaration.getMetadata());
        declarations.put(declarationSRef, matchFilter);
    }
41066
def put(self, namespacePrefix):
        """"""
        self.reqparse.add_argument('name', type=str, required=True)
        self.reqparse.add_argument('sortOrder', type=int, required=True)
        args = self.reqparse.parse_args()

        ns = db.ConfigNamespace.find_one(ConfigNamespace.namespace_prefix == namespacePrefix)
        if not ns:
            return self.make_response('No such namespace: {}'.format(namespacePrefix), HTTP.NOT_FOUND)

        ns.name = args['name']
        ns.sort_order = args['sortOrder']
        db.session.add(ns)
        db.session.commit()

        self.dbconfig.reload_data()
        auditlog(event='configNamespace.update', actor=session['user'].username, data=args)

        return self.make_response('Namespace updated')
1028130
public void setName(String name) {
        String oldname = this.name;
        this.name = name;
        //TODO Reset the main map
        save(oldname);
    }
819234
def set_name(self, new_name):
        

        yield from self._hypervisor.send('nio_bridge rename "{name}" "{new_name}"'.format(name=self._name,
                                                                                          new_name=new_name))

        self._name = new_name
971926
def add(self, name, *args):
        """"""
        self._add(False, self.authority, name, *args)
458730
def _AddOption(self, name):
    

    # Check for duplicate option declaration
    if name in [option.name for option in self.options]:
      raise TextFSMTemplateError('Duplicate option "%s"' % name)

    # Create the option object
    try:
      option = self._options_cls.GetOption(name)(self)
    except AttributeError:
      raise TextFSMTemplateError('Unknown option "%s"' % name)

    self.options.append(option)
899214
protected void addName() {
        if (Strings.isNotEmpty(builder)) {
            int endOffset = 0;
            if (Strings.endsWith(builder, tagSeparator)) { // Ends with ','.
                endOffset = 1;
            }
            if (Strings.startsWith(builder, inheritanceMarker)) { // Starts with '.'.
                inherits.add(builder.substring(1, builder.length() - endOffset));
            } else {
                tags.add(builder.substring(0, builder.length() - endOffset));
            }
            Strings.clearBuilder(builder);
        }
    }