rapydscript-ns 0.8.2 → 0.8.3

package/src/monaco-language-service/completions.js

@@ -45,6 +45,13 @@ export const KEYWORDS = [
  * @returns {{ type: string, objectName?: string, moduleName?: string, prefix: string }}
  */
 export function detect_context(linePrefix) {
+    // `obj.method().attr` — dot access on a call result (single-level call expression).
+    // Must be checked before the plain dot match since `[\w.]+` cannot span `()`.
+    const call_result_match = linePrefix.match(/([\w.]+)\([^)]*\)\.([\w]*)$/);
+    if (call_result_match) {
+        return { type: 'call_result', callPath: call_result_match[1], prefix: call_result_match[2] };
+    }
+
     // `obj.attr` or `obj.sub.attr` — dot access (captures multi-level path)
     const dot_match = linePrefix.match(/([\w.]+)\.([\w]*)$/);
     if (dot_match) {
@@ -265,6 +272,9 @@ export class CompletionEngine {
     getCompletions(scopeMap, position, linePrefix, monacoKind) {
         const ctx = detect_context(linePrefix);
 
+        if (ctx.type === 'call_result') {
+            return { suggestions: this._call_result_completions(position, ctx, monacoKind, scopeMap) };
+        }
         if (ctx.type === 'dot') {
             return { suggestions: this._dot_completions(scopeMap, position, ctx, monacoKind) };
         }
@@ -346,6 +356,82 @@ export class CompletionEngine {
         return items;
     }
 
+    // ---- Return-type helpers -----------------------------------------------
+
+    /**
+     * Analyze a module and return the `return_type` of a named function.
+     * @param {string} func_name
+     * @param {string} module_name
+     * @returns {string|null}
+     */
+    _get_return_type_from_module(func_name, module_name) {
+        const src = this._virtualFiles[module_name] || this._stdlibFiles[module_name];
+        if (!src) return null;
+        let mod_map;
+        try {
+            mod_map = this._analyzer.analyze(src, {});
+        } catch (_e) {
+            return null;
+        }
+        const mod_frame = mod_map.frames.find(f => f.kind === 'module');
+        if (!mod_frame) return null;
+        const fn_sym = mod_frame.getSymbol(func_name);
+        if (fn_sym && fn_sym.return_type) return fn_sym.return_type;
+        return null;
+    }
+
+    /**
+     * Resolve a type name (e.g. from inferred_class) through function return annotations,
+     * including cross-file imports. Returns the resolved type name, or null if unresolvable.
+     * @param {string} name
+     * @param {import('./scope.js').ScopeMap} scopeMap
+     * @returns {string|null}
+     */
+    _resolve_type_through_functions(name, scopeMap) {
+        let sym = null;
+        for (const frame of scopeMap.frames) {
+            const s = frame.getSymbol(name);
+            if (s) { sym = s; break; }
+        }
+        if (!sym) return null;
+
+        if (sym.kind === 'function' || sym.kind === 'method') {
+            // return_type is set by explicit annotation or inferred by the analyzer
+            if (sym.return_type) return sym.return_type;
+            return null;
+        }
+
+        if (sym.kind === 'import' && sym.source_module) {
+            const orig = sym.original_name || sym.name;
+            return this._get_return_type_from_module(orig, sym.source_module);
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the member map for a given type name.
+     * Checks builtins, then user class frames. Returns null if unknown.
+     * @param {string} type_name
+     * @param {import('./scope.js').ScopeMap|null} scopeMap
+     * @returns {Map|null}
+     */
+    _get_members_for_type(type_name, scopeMap) {
+        if (!type_name) return null;
+        if (this._builtins) {
+            const m = this._builtins.getTypeMembers(type_name);
+            if (m) return m;
+        }
+        if (scopeMap) {
+            for (const frame of scopeMap.frames) {
+                if (frame.kind === 'class' && frame.name === type_name) {
+                    return frame.symbols;
+                }
+            }
+        }
+        return null;
+    }
+
     // ---- Dot completions ---------------------------------------------------
 
     _dot_completions(scopeMap, position, ctx, monacoKind) {
@@ -413,6 +499,13 @@ export class CompletionEngine {
                 }
             }
 
+            // Resolve class_name through function return type annotations.
+            // e.g. x = getAllServers() → inferred_class='getAllServers' → resolve 'list'
+            if (class_name) {
+                const resolved = this._resolve_type_through_functions(class_name, scopeMap);
+                if (resolved) class_name = resolved;
+            }
+
             if (class_name) {
                 for (const frame of scopeMap.frames) {
                     if (frame.kind === 'class' && frame.name === class_name) {
@@ -433,7 +526,13 @@ export class CompletionEngine {
         // 1.5. Built-in type members — list, str, dict, number.
         //      Used when inferred_class names a built-in type, not a user class.
         if (!scope_matched && this._builtins && obj_sym && obj_sym.inferred_class) {
-            const members = this._builtins.getTypeMembers(obj_sym.inferred_class);
+            // Re-resolve in case inferred_class itself is a function name.
+            let type_name = obj_sym.inferred_class;
+            if (scopeMap) {
+                const resolved = this._resolve_type_through_functions(type_name, scopeMap);
+                if (resolved) type_name = resolved;
+            }
+            const members = this._builtins.getTypeMembers(type_name);
             if (members) {
                 scope_matched = true;
                 for (const [name, member] of members) {
@@ -496,6 +595,76 @@ export class CompletionEngine {
         return items;
     }
 
+    // ---- Call-result dot completions (e.g. ns.self().attr) -----------------
+
+    _call_result_completions(position, ctx, monacoKind, scopeMap) {
+        const range     = word_range(position, ctx.prefix);
+        const items     = [];
+        const seen      = new Set();
+        const call_path = ctx.callPath;
+        const last_dot  = call_path.lastIndexOf('.');
+
+        // --- DTS path (existing logic) ---
+        if (this._dts) {
+            let member_ti = null;
+            if (last_dot > 0) {
+                const object_path = call_path.slice(0, last_dot);
+                const method_name = call_path.slice(last_dot + 1);
+                member_ti = this._dts.getMemberInfo(object_path, method_name);
+            } else {
+                member_ti = this._dts.getGlobal(call_path);
+            }
+            if (member_ti && member_ti.return_type) {
+                const return_ti = this._dts.getGlobal(resolve_first_type(member_ti.return_type));
+                if (return_ti && return_ti.members) {
+                    for (const [name, member] of return_ti.members) {
+                        if (!ctx.prefix || name.startsWith(ctx.prefix)) {
+                            seen.add(name);
+                            items.push(_dts_member_to_item(member, range, monacoKind));
+                        }
+                    }
+                }
+            }
+        }
+
+        // --- User-defined function return types (scopeMap) ---
+        if (scopeMap && last_dot < 0) {
+            // Simple call like getAllServers() — look up function in scope
+            let sym = null;
+            for (const frame of scopeMap.frames) {
+                const s = frame.getSymbol(call_path);
+                if (s) { sym = s; break; }
+            }
+            if (sym) {
+                let return_type = null;
+                if (sym.kind === 'function' || sym.kind === 'method') {
+                    return_type = sym.return_type;
+                } else if (sym.kind === 'import' && sym.source_module) {
+                    const orig = sym.original_name || sym.name;
+                    return_type = this._get_return_type_from_module(orig, sym.source_module);
+                }
+                if (return_type) {
+                    const members = this._get_members_for_type(return_type, scopeMap);
+                    if (members) {
+                        for (const [name, member] of members) {
+                            if (!seen.has(name) && (!ctx.prefix || name.startsWith(ctx.prefix))) {
+                                seen.add(name);
+                                // members may be SymbolInfo (class frame) or TypeInfo/BuiltinInfo
+                                const item = member.kind === 'function' || member.kind === 'method' ||
+                                             member.kind === 'variable' || member.kind === 'parameter'
+                                    ? symbol_to_item(member, range, monacoKind, '0')
+                                    : _dts_member_to_item(member, range, monacoKind);
+                                items.push(item);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return items;
+    }
+
     // ---- from X import completions -----------------------------------------
 
     _from_import_completions(position, ctx, monacoKind) {

package/src/monaco-language-service/diagnostics.js

@@ -34,7 +34,7 @@ export const BASE_BUILTINS = (
     ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +
     ' Boolean encodeURIComponent decodeURIComponent setTimeout setInterval' +
     ' setImmediate clearTimeout clearInterval clearImmediate requestAnimationFrame' +
-    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis'
+    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice'
 ).split(' ');
 
 // ---------------------------------------------------------------------------

package/src/monaco-language-service/index.js

@@ -36,6 +36,13 @@ class ModelState {
         this._timer    = null;
         this._scopeMap = null;  // most recent ScopeMap for this model
 
+        // Derive the module name from the model URI so this model's content can
+        // be registered in _virtualFiles for cross-file import resolution.
+        // e.g. URI path "/scripts/utils.py" → module name "utils"
+        const uri_path = (model.uri && (model.uri.path || model.uri.fsPath)) || '';
+        const basename = uri_path.split('/').pop() || '';
+        this._module_name = basename.replace(/\.pyj?x?$/, '') || null;
+
         // Run immediately on first attach
         this._schedule(0);
 
@@ -55,6 +62,12 @@ class ModelState {
         const code    = this._model.getValue();
         const opts    = { virtualFiles: service._virtualFiles, stdlibFiles: service._stdlibFiles };
 
+        // Register this model's content in the shared virtualFiles pool so other
+        // open models can resolve cross-file imports from it.
+        if (this._module_name) {
+            service._virtualFiles[this._module_name] = code;
+        }
+
         // Diagnostics (syntax errors + lint markers)
         const markers = service._diagnostics.check(code, {
             ...opts,
@@ -69,6 +82,10 @@ class ModelState {
     dispose() {
         clearTimeout(this._timer);
         this._subscription.dispose();
+        // Remove this model's content from the virtualFiles pool on detach.
+        if (this._module_name) {
+            delete this._service._virtualFiles[this._module_name];
+        }
         // Clear markers when detaching
         this._service._monaco.editor.setModelMarkers(this._model, LANGUAGE_ID, []);
     }

package/src/monaco-language-service/scope.js

@@ -30,6 +30,9 @@ export class SymbolInfo {
         this.inferred_class = opts.inferred_class || null;  // 'ClassName' when x = ClassName(...)
         this.dts_call_path  = opts.dts_call_path  || null;  // 'ns.getServer' when x = ns.getServer(...)
         this.type           = null;              // Phase 6: TypeInfo
+        this.return_type    = opts.return_type   || null;  // annotated return type, e.g. 'list', 'str', 'MyClass'
+        this.source_module  = opts.source_module || null;  // module name when kind='import' (from X import Y)
+        this.original_name  = opts.original_name || null;  // pre-alias name for imports (from X import Y as Z → 'Y')
     }
 }
 

package/src/output/classes.pyj

@@ -214,7 +214,7 @@ def print_class(output):
                 output.end_statement()
 
         elif is_node_type(stmt, AST_Class):
-            console.error('Nested classes aren\'t supported yet')  # noqa:undef
+            pass  # nested classes are emitted in the statements section below
 
     if not defined_methods['__repr__']:
         define_default_method('__repr__', def():
@@ -271,9 +271,26 @@ def print_class(output):
             output.print(JSON.stringify(create_doctring(self.docstrings)))
         )
 
-    # Other statements in the class context
+    # Other statements in the class context (including nested class definitions)
     for stmt in self.statements:
-        if not is_node_type(stmt, AST_Method):
+        if is_node_type(stmt, AST_Class):
+            # Print the nested class in full, then attach it to the outer class.
+            # Two assignments mirror Python semantics:
+            #   Outer.Inner        — class-level access (Outer.Inner())
+            #   Outer.prototype.Inner — instance-level access (self.Inner() inside methods)
+            output.indent()
+            stmt.print(output)
+            output.newline()
+            nested_name = stmt.name.name
+            output.indent()
+            self.name.print(output)
+            output.print('.' + nested_name + ' = ' + nested_name)
+            output.end_statement()
+            output.indent()
+            self.name.print(output)
+            output.print('.prototype.' + nested_name + ' = ' + nested_name)
+            output.end_statement()
+        elif not is_node_type(stmt, AST_Method):
             output.indent()
             stmt.print(output)
             output.newline()

package/src/output/codegen.pyj

@@ -2,7 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-# globals:console,regenerate,writefile
+# globals:console,writefile
 
 from utils import noop
 from parse import PRECEDENCE

package/src/output/functions.pyj

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals:regenerate
 from __python__ import hash_literals
 
 from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, is_node_type
@@ -263,21 +262,10 @@ def function_definition(self, output, strip_first, as_expression):
     if self.is_generator:
         output.print('()'), output.space()
         output.with_block(def():
-            if output.options.js_version >= 6:
-                output.indent()
-                output.print('function* js_generator')
-                function_args(self.argnames, output, strip_first)
-                print_bracketed(self, output, True, function_preamble)
-            else:
-                temp = OutputStream({'beautify':True})
-                temp.print('function* js_generator')
-                function_args(self.argnames, temp, strip_first)
-                print_bracketed(self, temp, True, function_preamble)
-                transpiled = regenerate(temp.get(), output.options.beautify).replace(/regeneratorRuntime.(wrap|mark)/g, 'ρσ_regenerator.regeneratorRuntime.$1')
-                if output.options.beautify:
-                    ci = output.make_indent(0)
-                    transpiled = [ci + x for x in transpiled.split('\n')].join('\n')
-                output.print(transpiled)
+            output.indent()
+            output.print('function* js_generator')
+            function_args(self.argnames, output, strip_first)
+            print_bracketed(self, output, True, function_preamble)
             output.newline()
             output.indent()
             output.spaced('var', 'result', '=', 'js_generator.apply(this,', 'arguments)')

package/src/output/loops.pyj

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: regenerate
 from __python__ import hash_literals
 
 from ast import AST_BaseCall, AST_SymbolRef, AST_Array, AST_Unary, AST_Number, has_calls, AST_Seq, AST_ListComprehension, AST_Starred, is_node_type
@@ -436,8 +435,6 @@ def print_list_comprehension(self, output):
         output.with_block(def():
             body_out = output
             if is_generator:
-                if es5:
-                    body_out = OutputStream({'beautify':True})
                 body_out.indent()
                 body_out.print('function* js_generator()'), body_out.space(), body_out.print('{')
                 body_out.newline()
@@ -485,12 +482,6 @@ def print_list_comprehension(self, output):
             if is_generator:
                 output.set_indentation(previous_indentation)
                 body_out.newline(), body_out.indent(), body_out.print('}')  # end js_generator
-                if es5:
-                    transpiled = regenerate(body_out.get(), output.options.beautify).replace(/regeneratorRuntime.(wrap|mark)/g, 'ρσ_regenerator.regeneratorRuntime.$1')
-                    if output.options.beautify:
-                        ci = output.make_indent(0)
-                        transpiled = [ci + x for x in transpiled.split('\n')].join('\n')
-                    output.print(transpiled)
                 output.newline(), output.indent()
                 output.spaced('var', 'result', '=', 'js_generator.call(this)')
                 output.end_statement()

package/src/output/modules.pyj

@@ -18,7 +18,7 @@ def write_imports(module, output):
     imports = []
     for import_id in Object.keys(module.imports):
         imports.push(module.imports[import_id])
-    imports.sort(def(a, b):
+    imports.jssort(def(a, b):
         a, b = a.import_order, b.import_order
         return -1 if a < b else (1 if a > b else 0)
     )
@@ -122,9 +122,6 @@ def prologue(module, output):
         output.indent(), output.spaced('if(', 'typeof', 'HTMLCollection', '!==', '"undefined"', '&&', 'typeof', 'Symbol', '===', '"function")',
             'NodeList.prototype[Symbol.iterator]', '=', 'HTMLCollection.prototype[Symbol.iterator]', '=', 'NamedNodeMap.prototype[Symbol.iterator]', '=', 'Array.prototype[Symbol.iterator]')
         output.end_statement()
-    needs_yield = output.options.js_version < 6 and module.baselib['yield']
-    if needs_yield:
-        output.dump_yield()
     # output the baselib
     if not output.options.baselib_plain:
         raise ValueError('The baselib is missing! Remember to set the baselib_plain field on the options for OutputStream')

package/src/output/operators.pyj

@@ -280,6 +280,12 @@ def print_binary_op(self, output):
         write_smart_equality(self, output)
     elif self.operator is 'instanceof':
         write_instanceof(self.left, self.right, output)
+    elif self.operator is '+':
+        output.print('ρσ_list_add(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
     elif self.operator is '*' and is_node_type(self.left, AST_String):
         self.left.print(output), output.print('.repeat('), self.right.print(output), output.print(')')
     elif self.operator is '===' or self.operator is '!==':
@@ -415,6 +421,14 @@ def print_assign(self, output):
         else:
             output.print('Math.pow('), self.left.print(output), output.comma(), self.right.print(output), output.print(')')
         return
+    if self.operator is '+=':
+        output.assign(self.left)
+        output.print('ρσ_list_iadd(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
+        return
     if self.operator is '=' and self.is_chained():
         left_hand_sides, rhs = self.traverse_chain()
         is_compound_assign = False

package/src/output/stream.pyj

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals:regenerate
 from __python__ import hash_literals
 
 from utils import make_predicate, defaults, repeat_string
@@ -255,18 +254,6 @@ class OutputStream:
         if self.options.space_colon:
             self.space()
 
-    def dump_yield(self):
-        self.indent()
-        self.spaced('var', 'ρσ_regenerator', '=', '{}')
-        self.end_statement()
-        code = 'ρσ_regenerator.regeneratorRuntime = ' + regenerate(False, self.options.beautify)
-        if self.options.beautify:
-            code = code.replace(/\/\/.*$/mg, '\n').replace(/^\s*$/gm, '')  # strip comments
-            ci = self.make_indent(0)
-            code = [ci + x for x in code.split('\n')].join('\n')
-        self.print(code + '})(ρσ_regenerator)')
-        self.end_statement()
-
     def get(self):
         return self.OUTPUT
     toString = get

package/src/parse.pyj

@@ -1416,6 +1416,18 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         bases = v'[]'
         class_parent = None
 
+        # If this class is nested inside another class, register it under its
+        # full dotted path (e.g. "Outer.Inner") in the module-level class scope
+        # (S.classes[0]).  This lets get_class_in_scope() find "Outer.Inner" as
+        # a class and produce a correct AST_New constructor call instead of
+        # treating it as a method call on Outer.
+        outer_class_parts = []
+        for _outer in S.in_class:
+            if _outer:
+                outer_class_parts.push(_outer)
+        if outer_class_parts.length > 0:
+            S.classes[0][outer_class_parts.join('.') + '.' + name.name] = class_details
+
         # read the bases of the class, if any
         if is_("punc", "("):
             S.in_parenthesized_expr = True
@@ -1521,7 +1533,11 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         visitor = new walker()
 
         for stmt in definition.body:
-            if not is_node_type(stmt, AST_Class):
+            if is_node_type(stmt, AST_Class):
+                # Nested class: include in statements but don't walk through the
+                # class-var mangling visitor (nested classes have their own scope).
+                definition.statements.push(stmt)
+            else:
                 stmt.walk(visitor)
                 definition.statements.push(stmt)
         return definition

package/test/baselib.pyj

@@ -117,8 +117,8 @@ assrt.throws(def():a.index(8);, ValueError)
 assrt.throws(def():a.index(1, 1);, ValueError)
 assrt.throws(def():a.index(4, 1, 2);, ValueError)
 assrt.equal(1, a.index(2, 1, 2))
-assrt.throws(def():a.pypop(10);, IndexError)
-assrt.equal(a.pypop(-1), 4)
+assrt.throws(def():a.pop(10);, IndexError)
+assrt.equal(a.pop(-1), 4)
 assrt.deepEqual(a, [1,2,3])
 assrt.equal(a.remove(2), None)
 assrt.deepEqual(a, [1, 3])
@@ -141,9 +141,9 @@ assrt.ok(a.as_array().extend == undefined)
 a = [1, 2, 1]
 assrt.equal(a.count(1), 2)
 a = [3, 2, 4, 1]
-a.pysort()
+a.sort()
 assrt.deepEqual(a, [1,2,3,4])
-a.pysort(reverse=True)
+a.sort(reverse=True)
 assrt.deepEqual(a, [4,3,2,1])
 assrt.deepEqual(a, a.slice())
 assrt.ok(a is not a.slice())

package/test/classes.pyj

@@ -67,7 +67,7 @@ bound = angela.get_bound_method()
 assrt.equal(bound(), angela.how_long())
 
 # function methods
-assrt.deepEqual(dir(angela).sort(), [
+assrt.deepEqual(sorted(dir(angela)), [
     'HAIRS',
     "__init__",
     '__repr__',
@@ -137,22 +137,61 @@ inc()
 assrt.equal(c.count, 6)
 
 # nested classes
-# not yet fully implemented
-#class Molecule:
-#   class Atom:
-#       def __init__(self, element):
-#           self.element = element
-#
-#   def __init__(self, elements):
-#       self.structure = []
-#       for e in elements:
-#           self.structure.push(Molecule.Atom(e))
-#
-#water = Molecule(['H', "H", 'O'])
-#assrt.equal(len(water.structure), 3)
-#assrt.equal(water.structure[0].element, 'H')
-#for atom in water.structure:
-#   assrt.ok(isinstance(atom, Molecule.Atom))
+class Molecule:
+    class Atom:
+        def __init__(self, element):
+            self.element = element
+        def __repr__(self):
+            return 'Atom(' + self.element + ')'
+
+    def __init__(self, elements):
+        self.structure = []
+        for e in elements:
+            self.structure.push(Molecule.Atom(e))
+
+water = Molecule(['H', 'H', 'O'])
+assrt.equal(len(water.structure), 3)
+assrt.equal(water.structure[0].element, 'H')
+assrt.equal(water.structure[2].element, 'O')
+for atom in water.structure:
+    assrt.ok(isinstance(atom, Molecule.Atom))
+
+# nested class accessible via class reference and via instance attribute
+assrt.ok(Molecule.Atom is water.structure[0].__class__)
+# nested class can also be accessed via instance (self.Inner semantics)
+mol2 = Molecule(['C'])
+assrt.ok(isinstance(mol2.structure[0], mol2.Atom))
+
+# two levels of nesting
+class Universe:
+    class Galaxy:
+        class Star:
+            def __init__(self, name):
+                self.name = name
+        def __init__(self, star_name):
+            self.star = Universe.Galaxy.Star(star_name)
+    def __init__(self, star_name):
+        self.galaxy = Universe.Galaxy(star_name)
+
+u = Universe('Sol')
+assrt.equal(u.galaxy.star.name, 'Sol')
+assrt.ok(isinstance(u.galaxy.star, Universe.Galaxy.Star))
+
+# nested class with inheritance from outer-scope class
+class Animal:
+    def __init__(self, sound):
+        self.sound = sound
+
+class Zoo:
+    class Dog(Animal):
+        def __init__(self):
+            Animal.__init__(self, 'woof')
+
+zoo = Zoo()
+fido = Zoo.Dog()
+assrt.equal(fido.sound, 'woof')
+assrt.ok(isinstance(fido, Animal))
+assrt.ok(isinstance(fido, Zoo.Dog))
 
 # starargs and method decorators
 def negate(fn):

package/test/collections.pyj

@@ -62,18 +62,18 @@ assrt.equal(s[4:1:-2], 'ec')
 
 # sorting
 a = [2,1,3]
-a.pysort(key=def(x):return 0;)
+a.sort(key=def(x):return 0;)
 assrt.deepEqual(a, [2,1,3])  # stable sort
-a.pysort(reverse=True)
+a.sort(reverse=True)
 assrt.deepEqual(a, [3,2,1])
-a.pysort()
+a.sort()
 assrt.deepEqual(a, [1,2,3])
 
 # misc interface
 a = [1,2,3]
-assrt.equal(a.pypop(), 3)
+assrt.equal(a.pop(), 3)
 assrt.deepEqual(a, [1,2])
-assrt.equal(a.pypop(0), 1)
+assrt.equal(a.pop(0), 1)
 assrt.deepEqual(a, [2])
 
 # strings