Method emitFormalArguments

source/python.js:16676–16714

(def, self, schema, block)

                return new torch.FunctionSchema(def.name, '', args, returns);
            }
            emitFormalArguments(def, self, schema, block) {
                const args = [];
                const params = def.args.args;
                const expected_annotation_size = self ? def.args.args.length - 1 : def.args.args.length;
                if (schema.arguments.length !== expected_annotation_size) {
                    throw new python.Error('Invalid formal arguments.');
                }
                let it = 0;
                if (self) {
                    const param = params[it];
                    const name = param.arg;
                    const new_input = block.addInput().setDebugName(name);
                    this.environment_stack.setSugaredVar(param.range(), name, self.makeSugared(new_input), null);
                    args.push(new torch.Argument(name, new_input.type()));
                    it++;
                }
                const shouldDeriveType = this.shouldDeriveSetStateType(def, schema);
                let arg_annotation_idx = 0;
                for (; it < params.length; it++) {
                    const param = params[it];
                    const name = param.arg;
                    const new_input = block.addInput();
                    if (torch._C.meaningfulName(name)) {
                        new_input.setDebugName(name);
                    }
                    let arg = schema.arguments[arg_annotation_idx++];
                    if (shouldDeriveType) {
                        if (schema.arguments.length === 1) {
                            throw new python.Error('Invalid schema.');
                        }
                        const inferredStateType = this.getTypeForSetStateArg(def, self);
                        arg = arg.cloneWithType(inferredStateType);
                    }
                    args.push(arg);
                    new_input.setType(arg.type);
                    this.environment_stack.setVar(param.range(), name, new_input);
                }
                return args;
            }
            emitOutput(range, schema, block) {
                const ret_type = this._def_stack[this._def_stack.length - 1]._merged_return_type;
                const placeholder_return = this.graph.insertNode(this.graph.createUninitialized(ret_type)).output();