Method statement

source/python.js:22062–22194

(stmt, context)

    }

    statement(stmt, context) {
        const ast = this.ast;
        const builtins = this.builtins;
        if (stmt instanceof ast.Pass) {
            // pass
        } else if (stmt instanceof ast.Constant) {
            // pass
        } else if (stmt instanceof ast.Return) {
            return this.expression(stmt.value, context);
        } else if (stmt instanceof ast.FunctionDef) {
            const module = context.get('__name__');
            /* eslint-disable consistent-this */
            const self = this;
            /* eslint-enable consistent-this */
            const parent = context.get('__class__');
            const type = (parent === builtins.module) ? builtins.function : builtins.method;
            const func = {
                __class__: type,
                __globals__: context,
                __module__: module,
                __name__: stmt.name,
                __code__: stmt,
                __call__(args) {
                    return self.apply(this.__code__, args, this.__globals__);
                }
            };
            context.set(stmt.name, func);
        } else if (stmt instanceof ast.ClassDef) {
            const bases = stmt.bases.map((base) => this.base(base, context));
            if (bases.length > 1) {
                throw new python.Error(`Unsupported multiple bases for class '${stmt.name}'.`);
            }
            const base = bases.length === 1 ? bases[0] : null;
            const name = `${context.get('__name__')}.${stmt.name}`;
            const value = this._createType(name, base ? class extends base {} : class {});
            value.__bases__ = bases;
            context.set(stmt.name, value);
            this.block(stmt.body, new python.Execution.Context(context.globals, value.prototype));
        } else if (stmt instanceof ast.AnnAssign) {
            const target = this.identifier(stmt.target, context);
            context.set(target, stmt.value ? this.expression(stmt.value, context) : undefined);
        } else if (stmt instanceof ast.Assign) {
            this.expression(stmt, context);
        } else if (stmt instanceof ast.If) {
            const test = this.expression(stmt.test, context);
            if (test === true || test) {
                const value = this.block(stmt.body, context);
                if (value !== undefined) {
                    return value;
                }
            } else if (test === false) {
                if (stmt.orelse) {
                    const value = this.block(stmt.orelse, context);
                    if (value !== undefined) {
                        return value;
                    }
                }
            } else {