Method parseFakeAndRealType

source/python.js:11591–11721

()

                }
            }
            parseFakeAndRealType() {
                const L = this.L;
                let fake_value = null;
                let real_value = null;
                let alias_info = null;
                if (L.nextIf('(')) {
                    const types = [];
                    while (!L.nextIf(')')) {
                        const r = this.parseType();
                        types.push(r.first);
                        if (alias_info && r.second) {
                            alias_info.addContainedType(r.second);
                        }
                        L.nextIf(',');
                    }
                    real_value = torch.TupleType.create(types);
                    fake_value = real_value;
                } else if (L.cur().text() === 'Future') {
                    L.next();
                    L.expect('(');
                    const p = this.parseType();
                    const subtype = p.first;
                    // const subalias = p.second;
                    L.expect(')');
                    real_value = torch.FutureType.create(subtype);
                    fake_value = real_value;
                } else if (L.cur().text() === 'Await') {
                    L.next();
                    L.expect('(');
                    const p = this.parseType();
                    const subtype = p.first;
                    // const subalias = p.second;
                    L.expect(')');
                    real_value = torch.AwaitType.get(subtype);
                    fake_value = real_value;
                } else if (L.cur().text() === 'RRef') {
                    L.next();
                    L.expect('(');
                    const p = this.parseType();
                    const subtype = p.first;
                    // const subalias = p.second;
                    L.expect(')');
                    real_value = torch.RRefType.create(subtype);
                    fake_value = real_value;
                } else if (L.cur().text() === 'Tensor') {
                    L.next();
                    real_value = torch.TensorType.get();
                    fake_value = real_value;
                    alias_info = this.parseAliasAnnotation();
                } else if (L.cur().text() === 'Dict') {
                    L.next();
                    L.expect('(');
                    const key_type = this.parseType().first;
                    L.expect(',');
                    const value_type = this.parseType().first;
                    L.expect(')');
                    alias_info = this.parseAliasAnnotation();
                    real_value = torch.DictType.create(key_type, value_type);