rename

src/compiler.h

@@ -24,7 +24,7 @@ class Compiler {
     int lexing_count = 0;
     bool used = false;
     VM* vm;
-    emhash8::HashMap<_TokenType, GrammarRule> rules;
+    emhash8::HashMap<TokenIndex, GrammarRule> rules;
 
     _Code co() const{ return codes.top(); }
     CompileMode mode() const{ return parser->src->mode; }
@@ -39,7 +39,7 @@ public:
 // http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/
 #define METHOD(name) &Compiler::name
 #define NO_INFIX nullptr, PREC_NONE
-        for(_TokenType i=0; i<__TOKENS_LEN; i++) rules[i] = { nullptr, NO_INFIX };
+        for(TokenIndex i=0; i<kTokenCount; i++) rules[i] = { nullptr, NO_INFIX };
         rules[TK(".")] =    { nullptr,               METHOD(exprAttrib),         PREC_ATTRIB };
         rules[TK("(")] =    { METHOD(exprGrouping),  METHOD(exprCall),           PREC_CALL };
         rules[TK("[")] =    { METHOD(exprList),      METHOD(exprSubscript),      PREC_SUBSCRIPT };
@@ -112,7 +112,7 @@ private:
                 break;
             }
             if (c == '\0'){
-                if(quote3 && parser->src->mode == SINGLE_MODE){
+                if(quote3 && parser->src->mode == REPL_MODE){
                     throw NeedMoreLines(false);
                 }
                 SyntaxError("EOL while scanning string literal");
@@ -301,23 +301,23 @@ private:
         parser->set_next_token(TK("@eof"));
     }
 
-    inline _TokenType peek() {
+    inline TokenIndex peek() {
         return parser->curr.type;
     }
 
     // not sure this will work
-    _TokenType peek_next() {
+    TokenIndex peek_next() {
         if(parser->nexts.empty()) return TK("@eof");
         return parser->nexts.front().type;
     }
 
-    bool match(_TokenType expected) {
+    bool match(TokenIndex expected) {
         if (peek() != expected) return false;
         lex_token();
         return true;
     }
 
-    void consume(_TokenType expected) {
+    void consume(TokenIndex expected) {
         if (!match(expected)){
             _StrStream ss;
             ss << "expected '" << TK_STR(expected) << "', but got '" << TK_STR(peek()) << "'";
@@ -400,7 +400,7 @@ private:
     }
 
     void exprAssign() {
-        _TokenType op = parser->prev.type;
+        TokenIndex op = parser->prev.type;
         if(op == TK("=")) {     // a = (expr)
             EXPR_TUPLE();
             emit(OP_STORE_REF);
@@ -455,7 +455,7 @@ private:
     }
 
     void exprBinaryOp() {
-        _TokenType op = parser->prev.type;
+        TokenIndex op = parser->prev.type;
         parse_expression((Precedence)(rules[op].precedence + 1));
 
         switch (op) {
@@ -488,7 +488,7 @@ private:
     }
 
     void exprUnaryOp() {
-        _TokenType op = parser->prev.type;
+        TokenIndex op = parser->prev.type;
         parse_expression((Precedence)(PREC_UNARY + 1));
         switch (op) {
             case TK("-"):     emit(OP_UNARY_NEGATIVE); break;
@@ -499,9 +499,9 @@ private:
     }
 
     void exprGrouping() {
-        match_newlines(mode()==SINGLE_MODE);
+        match_newlines(mode()==REPL_MODE);
         EXPR_TUPLE();
-        match_newlines(mode()==SINGLE_MODE);
+        match_newlines(mode()==REPL_MODE);
         consume(TK(")"));
     }
 
@@ -510,13 +510,13 @@ private:
         int _body_start = co()->co_code.size();
         int ARGC = 0;
         do {
-            match_newlines(mode()==SINGLE_MODE);
+            match_newlines(mode()==REPL_MODE);
             if (peek() == TK("]")) break;
             EXPR(); ARGC++;
-            match_newlines(mode()==SINGLE_MODE);
+            match_newlines(mode()==REPL_MODE);
             if(ARGC == 1 && match(TK("for"))) goto __LISTCOMP;
         } while (match(TK(",")));
-        match_newlines(mode()==SINGLE_MODE);
+        match_newlines(mode()==REPL_MODE);
         consume(TK("]"));
         emit(OP_BUILD_LIST, ARGC);
         return;
@@ -528,7 +528,7 @@ __LISTCOMP:
         co()->co_code[_patch].arg = _body_end;
         emit(OP_BUILD_LIST, 0);
         EXPR_FOR_VARS();consume(TK("in"));EXPR_TUPLE();
-        match_newlines(mode()==SINGLE_MODE);
+        match_newlines(mode()==REPL_MODE);
         
         int _skipPatch = emit(OP_JUMP_ABSOLUTE);
         int _cond_start = co()->co_code.size();
@@ -559,7 +559,7 @@ __LISTCOMP:
 
         emit(OP_LOOP_CONTINUE, -1, true);
         co()->_exit_block();
-        match_newlines(mode()==SINGLE_MODE);
+        match_newlines(mode()==REPL_MODE);
         consume(TK("]"));
     }
 
@@ -567,7 +567,7 @@ __LISTCOMP:
         bool parsing_dict = false;
         int size = 0;
         do {
-            match_newlines(mode()==SINGLE_MODE);
+            match_newlines(mode()==REPL_MODE);
             if (peek() == TK("}")) break;
             EXPR();
             if(peek() == TK(":")) parsing_dict = true;
@@ -576,7 +576,7 @@ __LISTCOMP:
                 EXPR();
             }
             size++;
-            match_newlines(mode()==SINGLE_MODE);
+            match_newlines(mode()==REPL_MODE);
         } while (match(TK(",")));
         consume(TK("}"));
 
@@ -588,7 +588,7 @@ __LISTCOMP:
         int ARGC = 0;
         int KWARGC = 0;
         do {
-            match_newlines(mode()==SINGLE_MODE);
+            match_newlines(mode()==REPL_MODE);
             if (peek() == TK(")")) break;
             if(peek() == TK("@id") && peek_next() == TK("=")) {
                 consume(TK("@id"));
@@ -602,7 +602,7 @@ __LISTCOMP:
                 EXPR();
                 ARGC++;
             }
-            match_newlines(mode()==SINGLE_MODE);
+            match_newlines(mode()==REPL_MODE);
         } while (match(TK(",")));
         consume(TK(")"));
         emit(OP_CALL, (KWARGC << 16) | ARGC);
@@ -654,7 +654,7 @@ __LISTCOMP:
     }
 
     void exprValue() {
-        _TokenType op = parser->prev.type;
+        TokenIndex op = parser->prev.type;
         switch (op) {
             case TK("None"):    emit(OP_LOAD_NONE);  break;
             case TK("True"):    emit(OP_LOAD_TRUE);  break;
@@ -682,7 +682,7 @@ __LISTCOMP:
     void compile_block_body(CompilerAction action=nullptr) {
         if(action == nullptr) action = &Compiler::compile_stmt;
         consume(TK(":"));
-        if(!match_newlines(mode()==SINGLE_MODE)){
+        if(!match_newlines(mode()==REPL_MODE)){
             SyntaxError("expected a new line after ':'");
         }
         consume(TK("@indent"));
@@ -744,7 +744,7 @@ __LISTCOMP:
         (this->*prefix)();
         while (rules[peek()].precedence >= precedence) {
             lex_token();
-            _TokenType op = parser->prev.type;
+            TokenIndex op = parser->prev.type;
             GrammarFn infix = rules[op].infix;
             if(infix == nullptr) throw std::runtime_error("(infix == nullptr) is true");
             (this->*infix)();
@@ -914,7 +914,7 @@ __LISTCOMP:
             // If last op is not an assignment, pop the result.
             uint8_t last_op = co()->co_code.back().op;
             if( last_op!=OP_STORE_NAME && last_op!=OP_STORE_REF){
-                if(mode()==SINGLE_MODE && parser->indents.top()==0) emit(OP_PRINT_EXPR, -1, true);
+                if(mode()==REPL_MODE && parser->indents.top()==0) emit(OP_PRINT_EXPR, -1, true);
                 emit(OP_POP_TOP, -1, true);
             }
         }

src/error.h

@@ -3,8 +3,8 @@
 #include "safestl.h"
 
 struct NeedMoreLines {
-    NeedMoreLines(bool isClassDef) : isClassDef(isClassDef) {}
-    bool isClassDef;
+    NeedMoreLines(bool is_compiling_class) : is_compiling_class(is_compiling_class) {}
+    bool is_compiling_class;
 };
 
 struct HandledException {};
@@ -14,21 +14,21 @@ struct ToBeRaisedException {};
 enum CompileMode {
     EXEC_MODE,
     EVAL_MODE,
-    SINGLE_MODE,     // for REPL
+    REPL_MODE,
     JSON_MODE,
 };
 
 struct SourceData {
     const char* source;
     _Str filename;
-    std::vector<const char*> lineStarts;
+    std::vector<const char*> line_starts;
     CompileMode mode;
 
-    std::pair<const char*,const char*> getLine(int lineno) const {
+    std::pair<const char*,const char*> get_line(int lineno) const {
         if(lineno == -1) return {nullptr, nullptr};
         lineno -= 1;
         if(lineno < 0) lineno = 0;
-        const char* _start = lineStarts.at(lineno);
+        const char* _start = line_starts.at(lineno);
         const char* i = _start;
         while(*i != '\n' && *i != '\0') i++;
         return {_start, i};
@@ -40,32 +40,30 @@ struct SourceData {
         if (strncmp(source, "\xEF\xBB\xBF", 3) == 0) source += 3;
         this->filename = filename;
         this->source = source;
-        lineStarts.push_back(source);
+        line_starts.push_back(source);
         this->mode = mode;
     }
 
     _Str snapshot(int lineno, const char* cursor=nullptr){
         _StrStream ss;
         ss << "  " << "File \"" << filename << "\", line " << lineno << '\n';
-        std::pair<const char*,const char*> pair = getLine(lineno);
+        std::pair<const char*,const char*> pair = get_line(lineno);
         _Str line = "<?>";
-        int removedSpaces = 0;
+        int removed_spaces = 0;
         if(pair.first && pair.second){
             line = _Str(pair.first, pair.second-pair.first).lstrip();
-            removedSpaces = pair.second - pair.first - line.size();
+            removed_spaces = pair.second - pair.first - line.size();
             if(line.empty()) line = "<?>";
         }
         ss << "    " << line;
         if(cursor && line != "<?>" && cursor >= pair.first && cursor <= pair.second){
-            auto column = cursor - pair.first - removedSpaces;
+            auto column = cursor - pair.first - removed_spaces;
             if(column >= 0) ss << "\n    " << std::string(column, ' ') << "^";
         }
         return ss.str();
     }
 
-    ~SourceData(){
-        free((void*)source);
-    }
+    ~SourceData() { free((void*)source); }
 };
 
 class _Exception {

src/parser.h

@@ -2,9 +2,9 @@
 
 #include "obj.h"
 
-typedef uint8_t _TokenType;
+typedef uint8_t TokenIndex;
 
-constexpr const char* __TOKENS[] = {
+constexpr const char* kTokens[] = {
     "@error", "@eof", "@eol", "@sof",
     ".", ",", ":", ";", "#", "(", ")", "[", "]", "{", "}", "%",
     "+", "-", "*", "/", "//", "**", "=", ">", "<", "...", "->",
@@ -22,11 +22,11 @@ constexpr const char* __TOKENS[] = {
     "@indent", "@dedent"
 };
 
-const _TokenType __TOKENS_LEN = sizeof(__TOKENS) / sizeof(__TOKENS[0]);
+const TokenIndex kTokenCount = sizeof(kTokens) / sizeof(kTokens[0]);
 
-constexpr _TokenType TK(const char* const token) {
-    for(int k=0; k<__TOKENS_LEN; k++){
-        const char* i = __TOKENS[k];
+constexpr TokenIndex TK(const char* const token) {
+    for(int k=0; k<kTokenCount; k++){
+        const char* i = kTokens[k];
         const char* j = token;
         while(*i && *j && *i == *j) { i++; j++;}
         if(*i == *j) return k;
@@ -34,19 +34,19 @@ constexpr _TokenType TK(const char* const token) {
     return 0;
 }
 
-#define TK_STR(t) __TOKENS[t]
-const _TokenType __KW_BEGIN = TK("class");
-const _TokenType __KW_END = TK("raise");
+#define TK_STR(t) kTokens[t]
+const TokenIndex kTokenKwBegin = TK("class");
+const TokenIndex kTokenKwEnd = TK("raise");
 
-const emhash8::HashMap<std::string_view, _TokenType> __KW_MAP = [](){
-    emhash8::HashMap<std::string_view, _TokenType> map;
-    for(int k=__KW_BEGIN; k<=__KW_END; k++) map[__TOKENS[k]] = k;
+const emhash8::HashMap<std::string_view, TokenIndex> __KW_MAP = [](){
+    emhash8::HashMap<std::string_view, TokenIndex> map;
+    for(int k=kTokenKwBegin; k<=kTokenKwEnd; k++) map[kTokens[k]] = k;
     return map;
 }();
 
 
 struct Token{
-  _TokenType type;
+  TokenIndex type;
 
   const char* start; //< Begining of the token in the source.
   int length;        //< Number of chars of the token.
@@ -173,7 +173,7 @@ struct Parser {
         curr_char++;
         if (c == '\n'){
             current_line++;
-            src->lineStarts.push_back(curr_char);
+            src->line_starts.push_back(curr_char);
         }
         return c;
     }
@@ -266,7 +266,7 @@ struct Parser {
         return true;
     }
 
-    void set_next_token(_TokenType type, PyVar value=nullptr) {
+    void set_next_token(TokenIndex type, PyVar value=nullptr) {
         switch(type){
             case TK("{"): case TK("["): case TK("("): brackets_level++; break;
             case TK(")"): case TK("]"): case TK("}"): brackets_level--; break;
@@ -280,7 +280,7 @@ struct Parser {
         });
     }
 
-    void set_next_token_2(char c, _TokenType one, _TokenType two) {
+    void set_next_token_2(char c, TokenIndex one, TokenIndex two) {
         if (matchchar(c)) set_next_token(two);
         else set_next_token(one);
     }

src/pocketpy.h

@@ -82,7 +82,7 @@ void init_builtins(VM* _vm) {
 
     _vm->bind_builtin_func<1>("repr", CPP_LAMBDA(vm->asRepr(args[0])));
     _vm->bind_builtin_func<1>("hash", CPP_LAMBDA(vm->PyInt(vm->hash(args[0]))));
-    _vm->bind_builtin_func<1>("len", CPP_LAMBDA(vm->call(args[0], __len__, pkpy::noArg())));
+    _vm->bind_builtin_func<1>("len", CPP_LAMBDA(vm->call(args[0], __len__, pkpy::no_arg())));
 
     _vm->bind_builtin_func<1>("chr", [](VM* vm, const pkpy::Args& args) {
         i64 i = vm->PyInt_AS_C(args[0]);

src/repl.h

@@ -16,21 +16,21 @@ public:
     }
 
     bool input(std::string line){
-        CompileMode mode = SINGLE_MODE;
+        CompileMode mode = REPL_MODE;
         if(need_more_lines){
             buffer += line;
             buffer += '\n';
             int n = buffer.size();
             if(n>=need_more_lines){
                 for(int i=buffer.size()-need_more_lines; i<buffer.size(); i++){
-                    if(buffer[i] != '\n') goto __NOT_ENOUGH_LINES;
+                    // no enough lines
+                    if(buffer[i] != '\n') return true;
                 }
                 need_more_lines = 0;
                 line = buffer;
                 buffer.clear();
                 mode = EXEC_MODE;
             }else{
-__NOT_ENOUGH_LINES:
                 return true;
             }
         }
@@ -40,7 +40,7 @@ __NOT_ENOUGH_LINES:
         }catch(NeedMoreLines& ne){
             buffer += line;
             buffer += '\n';
-            need_more_lines = ne.isClassDef ? 3 : 2;
+            need_more_lines = ne.is_compiling_class ? 3 : 2;
             if (need_more_lines) return true;
         }
         return false;

src/safestl.h

@@ -36,43 +36,43 @@ typedef emhash8::HashMap<_Str, PyVar> PyVarDict;
 
 namespace pkpy {
     const int kMaxPoolSize = 10;
-    static thread_local std::vector<PyVar*>* _poolArgs = new std::vector<PyVar*>[kMaxPoolSize];
+    static thread_local std::vector<PyVar*>* _args_pool = new std::vector<PyVar*>[kMaxPoolSize];
 
     class Args {
         PyVar* _args;
         int _size;
 
-        void __tryAlloc(size_t n){
+        void _alloc(int n){
             if(n == 0){
                 this->_args = nullptr;
                 this->_size = 0;
                 return;
             }
-            if(n >= kMaxPoolSize || _poolArgs[n].empty()){
+            if(n >= kMaxPoolSize || _args_pool[n].empty()){
                 this->_args = new PyVar[n];
                 this->_size = n;
             }else{
-                this->_args = _poolArgs[n].back();
+                this->_args = _args_pool[n].back();
                 this->_size = n;
-                _poolArgs[n].pop_back();
+                _args_pool[n].pop_back();
             }
         }
 
-        void __tryRelease(){
+        void _release(){
             if(_size == 0 || _args == nullptr) return;
-            if(_size >= kMaxPoolSize || _poolArgs[_size].size() > 32){
+            if(_size >= kMaxPoolSize || _args_pool[_size].size() > 32){
                 delete[] _args;
             }else{
                 for(int i = 0; i < _size; i++) _args[i].reset();
-                _poolArgs[_size].push_back(_args);
+                _args_pool[_size].push_back(_args);
             }
         }
 
     public:
-        Args(size_t n){ __tryAlloc(n); }
+        Args(int n){ _alloc(n); }
 
         Args(const Args& other){
-            __tryAlloc(other._size);
+            _alloc(other._size);
             for(int i=0; i<_size; i++) _args[i] = other._args[i];
         }
 
@@ -84,7 +84,7 @@ namespace pkpy {
         }
 
         Args(PyVarList&& other) noexcept {
-            __tryAlloc(other.size());
+            _alloc(other.size());
             for(int i=0; i<_size; i++) _args[i] = std::move(other[i]);
             other.clear();
         }
@@ -93,7 +93,7 @@ namespace pkpy {
         const PyVar& operator[](int i) const { return _args[i]; }
 
         Args& operator=(Args&& other) noexcept {
-            __tryRelease();
+            _release();
             this->_args = other._args;
             this->_size = other._size;
             other._args = nullptr;
@@ -103,7 +103,7 @@ namespace pkpy {
 
         inline int size() const { return _size; }
 
-        PyVarList toList() const {
+        PyVarList to_list() const {
             PyVarList ret(_size);
             for(int i=0; i<_size; i++) ret[i] = _args[i];
             return ret;
@@ -113,36 +113,36 @@ namespace pkpy {
             static_assert(std::is_standard_layout_v<PyVar>);
             PyVar* old_args = _args;
             int old_size = _size;
-            __tryAlloc(old_size+1);
+            _alloc(old_size+1);
             _args[0] = self;
             if(old_size == 0) return;
 
             memcpy((void*)(_args+1), (void*)old_args, sizeof(PyVar)*old_size);
             memset((void*)old_args, 0, sizeof(PyVar)*old_size);
-            if(old_size >= kMaxPoolSize || _poolArgs[old_size].size() > 32){
+            if(old_size >= kMaxPoolSize || _args_pool[old_size].size() > 32){
                 delete[] old_args;
             }else{
-                _poolArgs[old_size].push_back(old_args);
+                _args_pool[old_size].push_back(old_args);
             }
         }
 
-        ~Args(){ __tryRelease(); }
+        ~Args(){ _release(); }
     };
 
-    const Args& noArg(){
+    const Args& no_arg(){
         static const Args ret(0);
         return ret;
     }
 
     template<typename T>
-    Args oneArg(T&& a) {
+    Args one_arg(T&& a) {
         Args ret(1);
         ret[0] = std::forward<T>(a);
         return ret;
     }
 
     template<typename T1, typename T2>
-    Args twoArgs(T1&& a, T2&& b) {
+    Args two_args(T1&& a, T2&& b) {
         Args ret(2);
         ret[0] = std::forward<T1>(a);
         ret[1] = std::forward<T2>(b);

src/vm.h

@@ -75,14 +75,14 @@ class VM {
                 for(int i=0; i<items.size(); i++){
                     if(!items[i]->is_type(_tp_ref)) {
                         done = true;
-                        PyVarList values = items.toList();
+                        PyVarList values = items.to_list();
                         for(int j=i; j<values.size(); j++) frame->try_deref(this, values[j]);
                         frame->push(PyTuple(values));
                         break;
                     }
                 }
                 if(done) break;
-                frame->push(PyRef(TupleRef(items.toList())));
+                frame->push(PyRef(TupleRef(items.to_list())));
             } break;
             case OP_BUILD_STRING:
             {
@@ -161,7 +161,7 @@ class VM {
             case OP_CONTAINS_OP:
                 {
                     PyVar rhs = frame->pop_value(this);
-                    bool ret_c = PyBool_AS_C(call(rhs, __contains__, pkpy::oneArg(frame->pop_value(this))));
+                    bool ret_c = PyBool_AS_C(call(rhs, __contains__, pkpy::one_arg(frame->pop_value(this))));
                     if(byte.arg == 1) ret_c = !ret_c;
                     frame->push(PyBool(ret_c));
                 } break;
@@ -202,23 +202,23 @@ class VM {
             case OP_RE_RAISE: _raise(); break;
             case OP_BUILD_LIST:
                 frame->push(PyList(
-                    frame->pop_n_values_reversed(this, byte.arg).toList()));
+                    frame->pop_n_values_reversed(this, byte.arg).to_list()));
                 break;
             case OP_BUILD_MAP:
                 {
                     pkpy::Args items = frame->pop_n_values_reversed(this, byte.arg*2);
                     PyVar obj = call(builtins->attribs["dict"]);
                     for(int i=0; i<items.size(); i+=2){
-                        call(obj, __setitem__, pkpy::twoArgs(items[i], items[i+1]));
+                        call(obj, __setitem__, pkpy::two_args(items[i], items[i+1]));
                     }
                     frame->push(obj);
                 } break;
             case OP_BUILD_SET:
                 {
                     PyVar list = PyList(
-                        frame->pop_n_values_reversed(this, byte.arg).toList()
+                        frame->pop_n_values_reversed(this, byte.arg).to_list()
                     );
-                    PyVar obj = call(builtins->attribs["set"], pkpy::oneArg(list));
+                    PyVar obj = call(builtins->attribs["set"], pkpy::one_arg(list));
                     frame->push(obj);
                 } break;
             case OP_DUP_TOP: frame->push(frame->top_value(this)); break;
@@ -411,23 +411,23 @@ public:
     }
 
     inline PyVar call(const PyVar& _callable){
-        return call(_callable, pkpy::noArg(), pkpy::noArg(), false);
+        return call(_callable, pkpy::no_arg(), pkpy::no_arg(), false);
     }
 
     template<typename ArgT>
     inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::Args>, PyVar>
     call(const PyVar& _callable, ArgT&& args){
-        return call(_callable, std::forward<ArgT>(args), pkpy::noArg(), false);
+        return call(_callable, std::forward<ArgT>(args), pkpy::no_arg(), false);
     }
 
     template<typename ArgT>
     inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::Args>, PyVar>
     call(const PyVar& obj, const _Str& func, ArgT&& args){
-        return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::noArg(), false);
+        return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::no_arg(), false);
     }
 
     inline PyVar call(const PyVar& obj, const _Str& func){
-        return call(getattr(obj, func), pkpy::noArg(), pkpy::noArg(), false);
+        return call(getattr(obj, func), pkpy::no_arg(), pkpy::no_arg(), false);
     }
 
     PyVar call(const PyVar& _callable, pkpy::Args args, const pkpy::Args& kwargs, bool opCall){
@@ -1028,15 +1028,15 @@ void AttrRef::del(VM* vm, Frame* frame) const{
 }
 
 PyVar IndexRef::get(VM* vm, Frame* frame) const{
-    return vm->call(obj, __getitem__, pkpy::oneArg(index));
+    return vm->call(obj, __getitem__, pkpy::one_arg(index));
 }
 
 void IndexRef::set(VM* vm, Frame* frame, PyVar val) const{
-    vm->call(obj, __setitem__, pkpy::twoArgs(index, val));
+    vm->call(obj, __setitem__, pkpy::two_args(index, val));
 }
 
 void IndexRef::del(VM* vm, Frame* frame) const{
-    vm->call(obj, __delitem__, pkpy::oneArg(index));
+    vm->call(obj, __delitem__, pkpy::one_arg(index));
 }
 
 PyVar TupleRef::get(VM* vm, Frame* frame) const{