Method emitSubscript

source/python.js:17957–18012

(subscript, type_hint)

                return this.emitSlice(loc, sliceable, maybe_dim, slice_exp);
            }
            emitSubscript(subscript, type_hint) {
                type_hint = type_hint === undefined ? null : type_hint;
                const sv = this.emitSugaredExpr(subscript.value, 1);
                const subscript_exprs = subscript.slice;
                const range = subscript.range();
                const val_range = subscript.value;
                if (subscript_exprs instanceof ast.Tuple) {
                    return new torch._C.SimpleValue(this.emitMultidimSlicing(range, sv.asValue(val_range, this.method), subscript_exprs));
                }
                if (subscript_exprs instanceof ast.Slice) {
                    if (sv.kind() === 'module') {
                        const s_tuple_val = sv.asTupleValue(val_range, this.method).asValue(val_range, this.method);
                        const [slice] = subscript_exprs;
                        const tuple_args = [];
                        if (slice.start().present()) {
                            const begin = new torch._C.NamedValue(val_range, 'begin', this.emitExpr(slice.start().get()));
                            tuple_args.push(begin);
                        } else {
                            tuple_args.push(null);
                        }
                        if (slice.end().present()) {
                            const end = new torch._C.NamedValue(val_range, 'end', this.emitExpr(slice.end().get()));
                            tuple_args.push(end);
                        } else {
                            tuple_args.push(null);
                        }
                        if (slice.step().present()) {
                            const step = new torch._C.NamedValue(val_range, 'step', this.emitExpr(slice.step().get()));
                            tuple_args.push(step);
                        } else {
                            tuple_args.push(null);
                        }
                        const tupleSliceValue = this.emitTupleSlice(val_range, s_tuple_val, tuple_args);
                        return new torch._C.SimpleValue(tupleSliceValue);
                    }
                    return new torch._C.SimpleValue(this.emitBasicSlice(range, sv.asValue(val_range, this.method), subscript_exprs));
                }
                const sliceable = sv.asValue(val_range, this.method);
                const subscript_sv = this.emitSugaredExpr(subscript_exprs, 1);
                if (subscript_sv instanceof torch._C.SliceValue) {
                    const slice_value = subscript_sv;
                    let dim = null;
                    if (sliceable.type().isSubtypeOf(torch.TensorType.get())) {
                        dim = this.method.graph().insertConstant(0, val_range);
                    }
                    const sliced = this.emitSliceOp(val_range, sliceable, dim, slice_value.start(), slice_value.stop(), slice_value.step());
                    return new torch._C.SimpleValue(sliced);
                }
                const idx = subscript_sv.asValue(val_range, this.method);
                if (sliceable.type() instanceof torch.TupleType) {
                    return new torch._C.SimpleValue(this.emitTupleIndex(range, sv.asValue(val_range, this.method), idx));
                } else if (sliceable.type().isSubtypeOf(torch.TensorType.get())) {
                    return new torch._C.SimpleValue(this.emitMultidimSlicing(range, sliceable, subscript_exprs));
                }
                return sv.getitem(range, this.method, idx, type_hint);
            }
        });
        this.registerType('torch.jit.CompilationUnit', class {