Copy disabled (too large)
Download .txt
Showing preview only (19,529K chars total). Download the full file to get everything.
Repository: traefik/yaegi
Branch: master
Commit: fcb76d1ece0c
Files: 1654
Total size: 18.4 MB
Directory structure:
gitextract_wer3ebvq/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.yml
│ │ ├── config.yml
│ │ └── feature_request.yml
│ └── workflows/
│ ├── go-cross.yml
│ ├── main.yml
│ └── release.yml
├── .gitignore
├── .golangci.yml
├── .goreleaser.yml
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── _test/
│ ├── a1.go
│ ├── a10.go
│ ├── a11.go
│ ├── a12.go
│ ├── a13.go
│ ├── a14.go
│ ├── a15.go
│ ├── a16.go
│ ├── a17.go
│ ├── a18.go
│ ├── a19.go
│ ├── a2.go
│ ├── a20.go
│ ├── a21.go
│ ├── a22.go
│ ├── a23.go
│ ├── a24.go
│ ├── a25.go
│ ├── a26.go
│ ├── a27.go
│ ├── a28.go
│ ├── a29.go
│ ├── a3.go
│ ├── a30.go
│ ├── a31.go
│ ├── a32.go
│ ├── a33.go
│ ├── a34.go
│ ├── a35.go
│ ├── a36.go
│ ├── a37.go
│ ├── a38.go
│ ├── a39.go
│ ├── a4.go
│ ├── a40.go
│ ├── a41.go
│ ├── a42.go
│ ├── a43.go
│ ├── a44.go
│ ├── a5.go
│ ├── a6.go
│ ├── a7.go
│ ├── a8.go
│ ├── a9.go
│ ├── add0.go
│ ├── add1.go
│ ├── add2.go
│ ├── addr0.go
│ ├── addr1.go
│ ├── addr2.go
│ ├── addr3.go
│ ├── addr4.go
│ ├── addr5.go
│ ├── and.go
│ ├── and0.go
│ ├── and1.go
│ ├── and2.go
│ ├── and3.go
│ ├── append0.go
│ ├── append1.go
│ ├── append2.go
│ ├── append3.go
│ ├── append4.go
│ ├── assert0.go
│ ├── assert1.go
│ ├── assert2.go
│ ├── assert3.go
│ ├── assert4.go
│ ├── assign.go
│ ├── assign0.go
│ ├── assign1.go
│ ├── assign10.go
│ ├── assign11.go
│ ├── assign12.go
│ ├── assign13.go
│ ├── assign14.go
│ ├── assign15.go
│ ├── assign16.go
│ ├── assign17.go
│ ├── assign18.go
│ ├── assign19.go
│ ├── assign2.go
│ ├── assign3.go
│ ├── assign4.go
│ ├── assign5.go
│ ├── assign6.go
│ ├── assign7.go
│ ├── assign8.go
│ ├── assign9.go
│ ├── b1/
│ │ └── foo/
│ │ └── foo.go
│ ├── b2/
│ │ └── foo/
│ │ └── foo.go
│ ├── bad0.go
│ ├── baz-bat/
│ │ └── baz-bat.go
│ ├── bin.go
│ ├── bin0.go
│ ├── bin1.go
│ ├── bin2.go
│ ├── bin3.go
│ ├── bin4.go
│ ├── bin5.go
│ ├── binstruct_ptr_map0.go
│ ├── binstruct_ptr_slice0.go
│ ├── binstruct_slice0.go
│ ├── bltn.go
│ ├── bltn0.go
│ ├── bool.go
│ ├── bool0.go
│ ├── bool1.go
│ ├── bool2.go
│ ├── bool3.go
│ ├── bool4.go
│ ├── bool5.go
│ ├── break0.go
│ ├── break1.go
│ ├── break2.go
│ ├── break3.go
│ ├── c1/
│ │ └── c1.go
│ ├── c2/
│ │ └── c2.go
│ ├── cap0.go
│ ├── chan0.go
│ ├── chan1.go
│ ├── chan10.go
│ ├── chan2.go
│ ├── chan3.go
│ ├── chan4.go
│ ├── chan5.go
│ ├── chan6.go
│ ├── chan7.go
│ ├── chan8.go
│ ├── chan9.go
│ ├── cli1.go
│ ├── cli2.go
│ ├── cli3.go
│ ├── cli4.go
│ ├── cli5.go
│ ├── cli6.go
│ ├── cli7.go
│ ├── cli8.go
│ ├── closure0.go
│ ├── closure1.go
│ ├── closure10.go
│ ├── closure11.go
│ ├── closure12.go
│ ├── closure13.go
│ ├── closure14.go
│ ├── closure15.go
│ ├── closure16.go
│ ├── closure17.go
│ ├── closure18.go
│ ├── closure19.go
│ ├── closure2.go
│ ├── closure20.go
│ ├── closure3.go
│ ├── closure4.go
│ ├── closure5.go
│ ├── closure6.go
│ ├── closure7.go
│ ├── closure8.go
│ ├── closure9.go
│ ├── comp0.go
│ ├── comp1.go
│ ├── comp2.go
│ ├── complex0.go
│ ├── complex1.go
│ ├── complex2.go
│ ├── complex3.go
│ ├── complex4.go
│ ├── composite0.go
│ ├── composite1.go
│ ├── composite10.go
│ ├── composite11.go
│ ├── composite12.go
│ ├── composite13.go
│ ├── composite14.go
│ ├── composite15.go
│ ├── composite16.go
│ ├── composite17.go
│ ├── composite18.go
│ ├── composite19.go
│ ├── composite2.go
│ ├── composite3.go
│ ├── composite4.go
│ ├── composite5.go
│ ├── composite6.go
│ ├── composite7.go
│ ├── composite8.go
│ ├── composite8bis.go
│ ├── composite9.go
│ ├── const0.go
│ ├── const1.go
│ ├── const10.go
│ ├── const11.go
│ ├── const12.go
│ ├── const13.go
│ ├── const14.go
│ ├── const15.go
│ ├── const16.go
│ ├── const17.go
│ ├── const18.go
│ ├── const19.go
│ ├── const2.go
│ ├── const20.go
│ ├── const21.go
│ ├── const22.go
│ ├── const23.go
│ ├── const24.go
│ ├── const25.go
│ ├── const26.go
│ ├── const3.go
│ ├── const4.go
│ ├── const5.go
│ ├── const6.go
│ ├── const7.go
│ ├── const8.go
│ ├── const9.go
│ ├── cont.go
│ ├── cont0.go
│ ├── cont1.go
│ ├── cont2.go
│ ├── cont3.go
│ ├── context.go
│ ├── context2.go
│ ├── convert0.go
│ ├── convert1.go
│ ├── convert2.go
│ ├── convert3.go
│ ├── copy0.go
│ ├── copy1.go
│ ├── copy2.go
│ ├── ct/
│ │ ├── ct1.go
│ │ ├── ct2.go
│ │ └── ct3.go
│ ├── ct1/
│ │ └── ct1.go
│ ├── d1/
│ │ └── d1.go
│ ├── d2/
│ │ └── d2.go
│ ├── d3.go
│ ├── defer0.go
│ ├── defer1.go
│ ├── defer2.go
│ ├── defer3.go
│ ├── defer4.go
│ ├── defer5.go
│ ├── defer6.go
│ ├── defer7.go
│ ├── defer8.go
│ ├── defer9.go
│ ├── delete0.go
│ ├── eval0.go
│ ├── export0.go
│ ├── export1.go
│ ├── factor.go
│ ├── fib.go
│ ├── fib0.go
│ ├── file_access.go
│ ├── flag0.go
│ ├── foo/
│ │ ├── bar.go
│ │ ├── bir.go
│ │ └── boo/
│ │ └── boo.go
│ ├── foo-bar/
│ │ └── foo-bar.go
│ ├── for0.go
│ ├── for1.go
│ ├── for10.go
│ ├── for11.go
│ ├── for12.go
│ ├── for13.go
│ ├── for14.go
│ ├── for15.go
│ ├── for16.go
│ ├── for17.go
│ ├── for18.go
│ ├── for19.go
│ ├── for2.go
│ ├── for3.go
│ ├── for4.go
│ ├── for5.go
│ ├── for6.go
│ ├── for7.go
│ ├── for8.go
│ ├── for9.go
│ ├── fun.go
│ ├── fun10.go
│ ├── fun11.go
│ ├── fun12.go
│ ├── fun13.go
│ ├── fun14.go
│ ├── fun15.go
│ ├── fun16.go
│ ├── fun17.go
│ ├── fun18.go
│ ├── fun19.go
│ ├── fun2.go
│ ├── fun20.go
│ ├── fun21.go
│ ├── fun22.go
│ ├── fun23.go
│ ├── fun24.go
│ ├── fun25.go
│ ├── fun26.go
│ ├── fun27.go
│ ├── fun28.go
│ ├── fun3.go
│ ├── fun4.go
│ ├── fun5.go
│ ├── fun6.go
│ ├── fun7.go
│ ├── fun8.go
│ ├── fun9.go
│ ├── gen1.go
│ ├── gen10.go
│ ├── gen11.go
│ ├── gen12.go
│ ├── gen13.go
│ ├── gen2.go
│ ├── gen3.go
│ ├── gen4.go
│ ├── gen5.go
│ ├── gen6.go
│ ├── gen7.go
│ ├── gen8.go
│ ├── gen9.go
│ ├── goto0.go
│ ├── goto1.go
│ ├── heap.go
│ ├── if.go
│ ├── if0.go
│ ├── if1.go
│ ├── if2.go
│ ├── if3.go
│ ├── if4.go
│ ├── if5.go
│ ├── if6.go
│ ├── if7.go
│ ├── imag0.go
│ ├── import0.go
│ ├── import1.go
│ ├── import2.go
│ ├── import3.go
│ ├── import4.go
│ ├── import5.go
│ ├── import6.go
│ ├── import7.go
│ ├── import8.go
│ ├── import9.go
│ ├── inc.go
│ ├── inception.go
│ ├── init0.go
│ ├── init1.go
│ ├── interface0.go
│ ├── interface1.go
│ ├── interface10.go
│ ├── interface11.go
│ ├── interface12.go
│ ├── interface13.go
│ ├── interface14.go
│ ├── interface15.go
│ ├── interface16.go
│ ├── interface17.go
│ ├── interface18.go
│ ├── interface19.go
│ ├── interface2.go
│ ├── interface20.go
│ ├── interface21.go
│ ├── interface22.go
│ ├── interface23.go
│ ├── interface24.go
│ ├── interface25.go
│ ├── interface26.go
│ ├── interface27.go
│ ├── interface28.go
│ ├── interface29.go
│ ├── interface3.go
│ ├── interface30.go
│ ├── interface31.go
│ ├── interface32.go
│ ├── interface33.go
│ ├── interface34.go
│ ├── interface35.go
│ ├── interface36.go
│ ├── interface37.go
│ ├── interface38.go
│ ├── interface39.go
│ ├── interface4.go
│ ├── interface40.go
│ ├── interface41.go
│ ├── interface42.go
│ ├── interface43.go
│ ├── interface44.go
│ ├── interface45.go
│ ├── interface46.go
│ ├── interface47.go
│ ├── interface48.go
│ ├── interface49.go
│ ├── interface5.go
│ ├── interface50.go
│ ├── interface51.go
│ ├── interface52.go
│ ├── interface6.go
│ ├── interface7.go
│ ├── interface8.go
│ ├── interface9.go
│ ├── interp.gi
│ ├── interp2.gi
│ ├── io0.go
│ ├── io1.go
│ ├── io2.go
│ ├── iota.go
│ ├── iota0.go
│ ├── ipp_as_key.go
│ ├── issue-1007.go
│ ├── issue-1010.go
│ ├── issue-1022.go
│ ├── issue-1052.go
│ ├── issue-1065.go
│ ├── issue-1068.go
│ ├── issue-1088.go
│ ├── issue-1089.go
│ ├── issue-1093.go
│ ├── issue-1094.go
│ ├── issue-1101.go
│ ├── issue-1115.go
│ ├── issue-1126.go
│ ├── issue-1128.go
│ ├── issue-1134.go
│ ├── issue-1136.go
│ ├── issue-1145.go
│ ├── issue-1156.go
│ ├── issue-1163.go
│ ├── issue-1166.go
│ ├── issue-1167.go
│ ├── issue-1173.go
│ ├── issue-1175.go
│ ├── issue-1177.go
│ ├── issue-1179.go
│ ├── issue-1181.go
│ ├── issue-1185.go
│ ├── issue-1187.go
│ ├── issue-1189.go
│ ├── issue-1202.go
│ ├── issue-1205.go
│ ├── issue-1208.go
│ ├── issue-1260.go
│ ├── issue-1276.go
│ ├── issue-1280.go
│ ├── issue-1285.go
│ ├── issue-1288.go
│ ├── issue-1300.go
│ ├── issue-1304.go
│ ├── issue-1306.go
│ ├── issue-1308.go
│ ├── issue-1311.go
│ ├── issue-1315.go
│ ├── issue-1320.go
│ ├── issue-1326.go
│ ├── issue-1328.go
│ ├── issue-1330.go
│ ├── issue-1332.go
│ ├── issue-1333.go
│ ├── issue-1337.go
│ ├── issue-1342.go
│ ├── issue-1344.go
│ ├── issue-1354.go
│ ├── issue-1355.go
│ ├── issue-1360.go
│ ├── issue-1361.go
│ ├── issue-1364.go
│ ├── issue-1365.go
│ ├── issue-1368.go
│ ├── issue-1371.go
│ ├── issue-1373.go
│ ├── issue-1375.go
│ ├── issue-1378.go
│ ├── issue-1381.go
│ ├── issue-1404.go
│ ├── issue-1408.go
│ ├── issue-1411.go
│ ├── issue-1416.go
│ ├── issue-1421.go
│ ├── issue-1425.go
│ ├── issue-1439.go
│ ├── issue-1442.go
│ ├── issue-1447.go
│ ├── issue-1451.go
│ ├── issue-1454.go
│ ├── issue-1459.go
│ ├── issue-1460.go
│ ├── issue-1465.go
│ ├── issue-1466.go
│ ├── issue-1470.go
│ ├── issue-1475.go
│ ├── issue-1488.go
│ ├── issue-1496.go
│ ├── issue-1515.go
│ ├── issue-1536.go
│ ├── issue-1571.go
│ ├── issue-1594.go
│ ├── issue-1618.go
│ ├── issue-1640.go
│ ├── issue-1653.go
│ ├── issue-435.go
│ ├── issue-558.go
│ ├── issue-735.go
│ ├── issue-770.go
│ ├── issue-772.go
│ ├── issue-775.go
│ ├── issue-776.go
│ ├── issue-782.go
│ ├── issue-784.go
│ ├── issue-880.go
│ ├── issue-981.go
│ ├── issue-993.go
│ ├── l2.go
│ ├── l3.go
│ ├── l4.go
│ ├── l5.go
│ ├── len0.go
│ ├── m1/
│ │ ├── main.go
│ │ └── main_test.go
│ ├── m2/
│ │ └── m2_test.go
│ ├── make.go
│ ├── make0.go
│ ├── make1.go
│ ├── make2.go
│ ├── map.go
│ ├── map10.go
│ ├── map11.go
│ ├── map12.go
│ ├── map13.go
│ ├── map14.go
│ ├── map15.go
│ ├── map16.go
│ ├── map17.go
│ ├── map18.go
│ ├── map19.go
│ ├── map2.go
│ ├── map20.go
│ ├── map21.go
│ ├── map22.go
│ ├── map23.go
│ ├── map24.go
│ ├── map25.go
│ ├── map26.go
│ ├── map27.go
│ ├── map28.go
│ ├── map29.go
│ ├── map3.go
│ ├── map30.go
│ ├── map31.go
│ ├── map4.go
│ ├── map5.go
│ ├── map6.go
│ ├── map7.go
│ ├── map8.go
│ ├── map9.go
│ ├── math0.go
│ ├── math1.go
│ ├── math2.go
│ ├── math3.go
│ ├── method.go
│ ├── method0.go
│ ├── method1.go
│ ├── method10.go
│ ├── method11.go
│ ├── method12.go
│ ├── method13.go
│ ├── method14.go
│ ├── method15.go
│ ├── method16.go
│ ├── method17.go
│ ├── method18.go
│ ├── method19.go
│ ├── method2.go
│ ├── method20.go
│ ├── method21.go
│ ├── method22.go
│ ├── method23.go
│ ├── method24.go
│ ├── method25.go
│ ├── method26.go
│ ├── method27.go
│ ├── method28.go
│ ├── method29.go
│ ├── method3.go
│ ├── method30.go
│ ├── method31.go
│ ├── method32.go
│ ├── method33.go
│ ├── method34.go
│ ├── method35.go
│ ├── method36.go
│ ├── method37.go
│ ├── method38/
│ │ ├── a.go
│ │ └── b.go
│ ├── method38.go
│ ├── method39.go
│ ├── method4.go
│ ├── method40.go
│ ├── method5.go
│ ├── method6.go
│ ├── method7.go
│ ├── method8.go
│ ├── method9.go
│ ├── named0.go
│ ├── named1.go
│ ├── named2.go
│ ├── named3/
│ │ └── named3.go
│ ├── named3.go
│ ├── named4.go
│ ├── neg0.go
│ ├── new0.go
│ ├── new1.go
│ ├── new2.go
│ ├── nil0.go
│ ├── nil1.go
│ ├── nil2.go
│ ├── nil3.go
│ ├── not0.go
│ ├── not1.go
│ ├── not2.go
│ ├── num0.go
│ ├── op0.go
│ ├── op1.go
│ ├── op10.go
│ ├── op11.go
│ ├── op2.go
│ ├── op3.go
│ ├── op4.go
│ ├── op5.go
│ ├── op6.go
│ ├── op7.go
│ ├── op8.go
│ ├── op9.go
│ ├── opfloat32.go
│ ├── opfloat64.go
│ ├── opint16.go
│ ├── opint32.go
│ ├── opint64.go
│ ├── opint8.go
│ ├── opstring.go
│ ├── opuint16.go
│ ├── opuint32.go
│ ├── opuint64.go
│ ├── opuint8.go
│ ├── or0.go
│ ├── or1.go
│ ├── or2.go
│ ├── os0.go
│ ├── p1/
│ │ ├── s1.go
│ │ └── s2.go
│ ├── p2/
│ │ └── p2.go
│ ├── p3/
│ │ └── empty
│ ├── p4/
│ │ └── p4.go
│ ├── p5/
│ │ └── p5.go
│ ├── p5.go
│ ├── p6/
│ │ └── p6.go
│ ├── p6.go
│ ├── panic0.go
│ ├── pkgname0.go
│ ├── pkgname1.go
│ ├── pkgname2.go
│ ├── primes.go
│ ├── print0.go
│ ├── ptr0.go
│ ├── ptr1.go
│ ├── ptr2.go
│ ├── ptr3.go
│ ├── ptr4.go
│ ├── ptr5.go
│ ├── ptr5a.go
│ ├── ptr6.go
│ ├── ptr7.go
│ ├── ptr8.go
│ ├── ptr_array0.go
│ ├── ptr_array1.go
│ ├── ptr_array2.go
│ ├── ptr_array3.go
│ ├── range0.go
│ ├── range1.go
│ ├── range2.go
│ ├── range3.go
│ ├── range4.go
│ ├── range5.go
│ ├── range6.go
│ ├── range7.go
│ ├── range8.go
│ ├── range9.go
│ ├── real0.go
│ ├── recover0.go
│ ├── recover1.go
│ ├── recover2.go
│ ├── recover3.go
│ ├── recover4.go
│ ├── recurse0.go
│ ├── recurse1.go
│ ├── recurse2.go
│ ├── recurse3.go
│ ├── redeclaration-global0.go
│ ├── redeclaration-global1.go
│ ├── redeclaration-global2.go
│ ├── redeclaration-global3.go
│ ├── redeclaration-global4.go
│ ├── redeclaration-global5.go
│ ├── redeclaration-global6.go
│ ├── redeclaration-global7.go
│ ├── redeclaration0.go
│ ├── redeclaration1.go
│ ├── redeclaration2.go
│ ├── redeclaration3.go
│ ├── redeclaration4.go
│ ├── redeclaration5.go
│ ├── restricted0.go
│ ├── restricted1.go
│ ├── restricted2.go
│ ├── restricted3.go
│ ├── ret1.go
│ ├── ret2.go
│ ├── ret3.go
│ ├── ret4.go
│ ├── ret5.go
│ ├── ret6.go
│ ├── ret7.go
│ ├── ret8.go
│ ├── run0.go
│ ├── run1.go
│ ├── run10.go
│ ├── run11.go
│ ├── run12.go
│ ├── run13.go
│ ├── run4.go
│ ├── run5.go
│ ├── run6.go
│ ├── run7.go
│ ├── run8.go
│ ├── run9.go
│ ├── rune0.go
│ ├── rune1.go
│ ├── rune2.go
│ ├── sample.plugin
│ ├── scope0.go
│ ├── scope1.go
│ ├── scope2.go
│ ├── scope3.go
│ ├── scope4.go
│ ├── scope5.go
│ ├── scope6.go
│ ├── scope7.go
│ ├── secure.gi
│ ├── select.go
│ ├── select0.go
│ ├── select1.go
│ ├── select10.go
│ ├── select11.go
│ ├── select12.go
│ ├── select13.go
│ ├── select14.go
│ ├── select15.go
│ ├── select2.go
│ ├── select3.go
│ ├── select4.go
│ ├── select5.go
│ ├── select6.go
│ ├── select7.go
│ ├── select8.go
│ ├── select9.go
│ ├── selector-scope0.go
│ ├── server.go
│ ├── server0.go
│ ├── server1.go
│ ├── server1a.go
│ ├── server2.go
│ ├── server3.go
│ ├── server4.go
│ ├── server5.go
│ ├── server6.go
│ ├── server7.go
│ ├── shift0.go
│ ├── shift1.go
│ ├── shift2.go
│ ├── shift3.go
│ ├── sieve.go
│ ├── slice.go
│ ├── str.go
│ ├── str0.go
│ ├── str1.go
│ ├── str2.go
│ ├── str3.go
│ ├── str4.go
│ ├── struct.go
│ ├── struct0.go
│ ├── struct0a.go
│ ├── struct1.go
│ ├── struct10.go
│ ├── struct11.go
│ ├── struct12.go
│ ├── struct13.go
│ ├── struct14.go
│ ├── struct15.go
│ ├── struct16.go
│ ├── struct17.go
│ ├── struct18.go
│ ├── struct19.go
│ ├── struct2.go
│ ├── struct20.go
│ ├── struct21.go
│ ├── struct22.go
│ ├── struct23.go
│ ├── struct24.go
│ ├── struct25.go
│ ├── struct26.go
│ ├── struct27.go
│ ├── struct28.go
│ ├── struct29.go
│ ├── struct3.go
│ ├── struct30.go
│ ├── struct31.go
│ ├── struct32.go
│ ├── struct33.go
│ ├── struct34.go
│ ├── struct35.go
│ ├── struct36.go
│ ├── struct37.go
│ ├── struct38.go
│ ├── struct39.go
│ ├── struct4.go
│ ├── struct40.go
│ ├── struct41.go
│ ├── struct42.go
│ ├── struct43.go
│ ├── struct44.go
│ ├── struct45.go
│ ├── struct46.go
│ ├── struct47.go
│ ├── struct48.go
│ ├── struct49.go
│ ├── struct5.go
│ ├── struct50.go
│ ├── struct51.go
│ ├── struct52.go
│ ├── struct53.go
│ ├── struct54.go
│ ├── struct55.go
│ ├── struct56.go
│ ├── struct57.go
│ ├── struct58.go
│ ├── struct59.go
│ ├── struct6.go
│ ├── struct60.go
│ ├── struct61.go
│ ├── struct62.go
│ ├── struct7.go
│ ├── struct8.go
│ ├── struct9.go
│ ├── switch.go
│ ├── switch0.go
│ ├── switch1.go
│ ├── switch10.go
│ ├── switch11.go
│ ├── switch12.go
│ ├── switch13.go
│ ├── switch14.go
│ ├── switch15.go
│ ├── switch16.go
│ ├── switch17.go
│ ├── switch18.go
│ ├── switch19.go
│ ├── switch2.go
│ ├── switch20.go
│ ├── switch21.go
│ ├── switch22.go
│ ├── switch23.go
│ ├── switch24.go
│ ├── switch25.go
│ ├── switch26.go
│ ├── switch27.go
│ ├── switch28.go
│ ├── switch29.go
│ ├── switch3.go
│ ├── switch30.go
│ ├── switch31.go
│ ├── switch32.go
│ ├── switch33.go
│ ├── switch34.go
│ ├── switch35.go
│ ├── switch36.go
│ ├── switch37.go
│ ├── switch38.go
│ ├── switch39.go
│ ├── switch4.go
│ ├── switch40.go
│ ├── switch5.go
│ ├── switch6.go
│ ├── switch7.go
│ ├── switch8.go
│ ├── switch9.go
│ ├── tag0.go
│ ├── testdata/
│ │ └── redeclaration-global7/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── quux.go
│ │ ├── baz/
│ │ │ └── quux.go
│ │ ├── tata/
│ │ │ └── tutu.go
│ │ └── toto/
│ │ └── titi.go
│ ├── time0.go
│ ├── time1.go
│ ├── time10.go
│ ├── time11.go
│ ├── time12.go
│ ├── time13.go
│ ├── time14.go
│ ├── time15.go
│ ├── time16.go
│ ├── time2.go
│ ├── time3.go
│ ├── time4.go
│ ├── time5.go
│ ├── time6.go
│ ├── time7.go
│ ├── time8.go
│ ├── time9.go
│ ├── type0.go
│ ├── type1.go
│ ├── type10.go
│ ├── type11.go
│ ├── type12.go
│ ├── type13.go
│ ├── type14.go
│ ├── type15.go
│ ├── type16.go
│ ├── type17.go
│ ├── type18.go
│ ├── type19.go
│ ├── type2.go
│ ├── type20.go
│ ├── type21.go
│ ├── type22.go
│ ├── type23.go
│ ├── type24.go
│ ├── type25.go
│ ├── type26.go
│ ├── type27.go
│ ├── type28.go
│ ├── type29.go
│ ├── type3.go
│ ├── type30.go
│ ├── type31.go
│ ├── type32.go
│ ├── type33.go
│ ├── type34.go
│ ├── type4.go
│ ├── type5.go
│ ├── type6.go
│ ├── type7.go
│ ├── type8.go
│ ├── type9.go
│ ├── unsafe0.go
│ ├── unsafe1.go
│ ├── unsafe10.go
│ ├── unsafe2.go
│ ├── unsafe3.go
│ ├── unsafe4.go
│ ├── unsafe5.go
│ ├── unsafe6.go
│ ├── unsafe7.go
│ ├── unsafe8.go
│ ├── var.go
│ ├── var10.go
│ ├── var11.go
│ ├── var12.go
│ ├── var13.go
│ ├── var14.go
│ ├── var15.go
│ ├── var16.go
│ ├── var2.go
│ ├── var3.go
│ ├── var4.go
│ ├── var5.go
│ ├── var6.go
│ ├── var7.go
│ ├── var8.go
│ ├── var9.go
│ ├── variadic.go
│ ├── variadic0.go
│ ├── variadic1.go
│ ├── variadic10.go
│ ├── variadic2.go
│ ├── variadic3.go
│ ├── variadic4.go
│ ├── variadic5.go
│ ├── variadic6.go
│ ├── variadic7.go
│ ├── variadic8.go
│ ├── variadic9.go
│ └── vars/
│ ├── first.go
│ └── second.go
├── cmd/
│ └── yaegi/
│ ├── extract.go
│ ├── help.go
│ ├── run.go
│ ├── test.go
│ ├── yaegi.go
│ └── yaegi_test.go
├── example/
│ ├── closure/
│ │ ├── _pkg/
│ │ │ └── src/
│ │ │ └── foo/
│ │ │ └── bar/
│ │ │ └── bar.go
│ │ └── closure_test.go
│ ├── fs/
│ │ └── fs_test.go
│ ├── getfunc/
│ │ ├── _gopath/
│ │ │ └── src/
│ │ │ └── github.com/
│ │ │ └── foo/
│ │ │ └── bar/
│ │ │ └── foobar.go
│ │ └── getfunc_test.go
│ └── pkg/
│ ├── _pkg/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ └── fromage.go
│ ├── _pkg0/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ ├── cheese/
│ │ │ │ └── cheese.go
│ │ │ └── fromage.go
│ │ └── pkg.go
│ ├── _pkg1/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ └── pkg.go
│ ├── _pkg10/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ └── fromage.go
│ ├── _pkg11/
│ │ └── src/
│ │ └── foo/
│ │ ├── foo.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ └── fromage.go
│ ├── _pkg12/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── foo/
│ │ ├── main.go
│ │ ├── pkg/
│ │ │ └── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── bar/
│ │ └── bar.go
│ ├── _pkg13/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── foo/
│ │ └── bar/
│ │ ├── main.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── bat/
│ │ └── baz/
│ │ └── baz.go
│ ├── _pkg2/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ ├── fromage.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ └── fromage.go
│ ├── _pkg3/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ ├── couteau/
│ │ │ └── couteau.go
│ │ ├── fromage.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ └── fromage.go
│ ├── _pkg4/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ ├── couteau/
│ │ │ └── couteau.go
│ │ ├── fromage.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ ├── cheese.go
│ │ └── vin/
│ │ └── vin.go
│ ├── _pkg5/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ ├── cheese/
│ │ │ ├── cheese.go
│ │ │ └── vin/
│ │ │ └── vin.go
│ │ └── fromage/
│ │ ├── couteau/
│ │ │ └── couteau.go
│ │ └── fromage.go
│ ├── _pkg6/
│ │ └── src/
│ │ ├── github.com/
│ │ │ └── foo/
│ │ │ └── pkg/
│ │ │ ├── pkg.go
│ │ │ └── vendor/
│ │ │ └── guthib.com/
│ │ │ └── traefik/
│ │ │ └── fromage/
│ │ │ ├── couteau/
│ │ │ │ └── couteau.go
│ │ │ └── fromage.go
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ ├── cheese.go
│ │ └── vin/
│ │ └── vin.go
│ ├── _pkg7/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ └── vin/
│ │ ├── vendor/
│ │ │ └── guthib.com/
│ │ │ └── traefik/
│ │ │ └── cheese/
│ │ │ └── cheese.go
│ │ └── vin.go
│ ├── _pkg8/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ └── pkg.go
│ ├── _pkg9/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ ├── pkg.go
│ │ └── pkgfalse.go
│ └── pkg_test.go
├── extract/
│ ├── extract.go
│ ├── extract_test.go
│ └── testdata/
│ ├── 1/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz/
│ │ ├── baz.go
│ │ └── go.mod
│ ├── 2/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz/
│ │ └── baz.go
│ ├── 3/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz/
│ │ ├── baz.go
│ │ └── go.mod
│ ├── 4/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── bar/
│ │ ├── main.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── baz/
│ │ ├── baz.go
│ │ └── go.mod
│ ├── 5/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── bar/
│ │ ├── main.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── baz/
│ │ └── baz.go
│ ├── 6/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz-baz/
│ │ ├── baz.go
│ │ └── go.mod
│ └── 7/
│ └── src/
│ └── guthib.com/
│ └── variadic/
│ ├── go.mod
│ └── variadic.go
├── generate.go
├── go.mod
├── install.sh
├── internal/
│ ├── cmd/
│ │ ├── extract/
│ │ │ └── extract.go
│ │ └── genop/
│ │ └── genop.go
│ └── unsafe2/
│ ├── go1_20_unsafe.go
│ ├── go1_21_unsafe.go
│ └── unsafe_test.go
├── interp/
│ ├── ast.go
│ ├── build.go
│ ├── build_test.go
│ ├── cfg.go
│ ├── compile_test.go
│ ├── debugger.go
│ ├── doc.go
│ ├── dot.go
│ ├── example_eval_test.go
│ ├── export_test.go
│ ├── generic.go
│ ├── gta.go
│ ├── hooks.go
│ ├── interp.go
│ ├── interp_chan_test.go
│ ├── interp_consistent_test.go
│ ├── interp_eval_test.go
│ ├── interp_export_test.go
│ ├── interp_file_test.go
│ ├── interp_issue_1634_test.go
│ ├── interp_test.go
│ ├── op.go
│ ├── program.go
│ ├── realfs.go
│ ├── run.go
│ ├── scope.go
│ ├── self_example_test.go
│ ├── src.go
│ ├── src_test.go
│ ├── testdata/
│ │ ├── concurrent/
│ │ │ ├── composite/
│ │ │ │ ├── composite_lit.go
│ │ │ │ └── composite_sparse.go
│ │ │ ├── hello1.go
│ │ │ └── hello2.go
│ │ ├── multi/
│ │ │ └── 731/
│ │ │ ├── sample1.go
│ │ │ ├── sample2.go
│ │ │ └── sample3.go
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ ├── bar/
│ │ │ └── baz/
│ │ │ └── baz.go
│ │ └── vendor/
│ │ └── whatever/
│ │ └── whatever.go
│ ├── trace.go
│ ├── type.go
│ ├── typecheck.go
│ ├── typestring.go
│ ├── use.go
│ └── value.go
└── stdlib/
├── generic/
│ ├── go1_21_cmp.go.txt
│ ├── go1_21_generic.go
│ ├── go1_21_maps.go.txt
│ ├── go1_21_slices.go.txt
│ ├── go1_21_sync.go.txt
│ ├── go1_21_sync_atomic.go.txt
│ ├── go1_22_cmp_cmp.go.txt
│ ├── go1_22_generic.go
│ ├── go1_22_maps_maps.go.txt
│ ├── go1_22_slices_slices.go.txt
│ ├── go1_22_slices_sort.go.txt
│ ├── go1_22_slices_zsortanyfunc.go.txt
│ ├── go1_22_sync_atomic_type.go.txt
│ └── go1_22_sync_oncefunc.go.txt
├── go1_21_archive_tar.go
├── go1_21_archive_zip.go
├── go1_21_bufio.go
├── go1_21_bytes.go
├── go1_21_cmp.go
├── go1_21_compress_bzip2.go
├── go1_21_compress_flate.go
├── go1_21_compress_gzip.go
├── go1_21_compress_lzw.go
├── go1_21_compress_zlib.go
├── go1_21_container_heap.go
├── go1_21_container_list.go
├── go1_21_container_ring.go
├── go1_21_context.go
├── go1_21_crypto.go
├── go1_21_crypto_aes.go
├── go1_21_crypto_cipher.go
├── go1_21_crypto_des.go
├── go1_21_crypto_dsa.go
├── go1_21_crypto_ecdh.go
├── go1_21_crypto_ecdsa.go
├── go1_21_crypto_ed25519.go
├── go1_21_crypto_elliptic.go
├── go1_21_crypto_hmac.go
├── go1_21_crypto_md5.go
├── go1_21_crypto_rand.go
├── go1_21_crypto_rc4.go
├── go1_21_crypto_rsa.go
├── go1_21_crypto_sha1.go
├── go1_21_crypto_sha256.go
├── go1_21_crypto_sha512.go
├── go1_21_crypto_subtle.go
├── go1_21_crypto_tls.go
├── go1_21_crypto_x509.go
├── go1_21_crypto_x509_pkix.go
├── go1_21_database_sql.go
├── go1_21_database_sql_driver.go
├── go1_21_debug_buildinfo.go
├── go1_21_debug_dwarf.go
├── go1_21_debug_elf.go
├── go1_21_debug_gosym.go
├── go1_21_debug_macho.go
├── go1_21_debug_pe.go
├── go1_21_debug_plan9obj.go
├── go1_21_encoding.go
├── go1_21_encoding_ascii85.go
├── go1_21_encoding_asn1.go
├── go1_21_encoding_base32.go
├── go1_21_encoding_base64.go
├── go1_21_encoding_binary.go
├── go1_21_encoding_csv.go
├── go1_21_encoding_gob.go
├── go1_21_encoding_hex.go
├── go1_21_encoding_json.go
├── go1_21_encoding_pem.go
├── go1_21_encoding_xml.go
├── go1_21_errors.go
├── go1_21_expvar.go
├── go1_21_flag.go
├── go1_21_fmt.go
├── go1_21_go_ast.go
├── go1_21_go_build.go
├── go1_21_go_build_constraint.go
├── go1_21_go_constant.go
├── go1_21_go_doc.go
├── go1_21_go_doc_comment.go
├── go1_21_go_format.go
├── go1_21_go_importer.go
├── go1_21_go_parser.go
├── go1_21_go_printer.go
├── go1_21_go_scanner.go
├── go1_21_go_token.go
├── go1_21_go_types.go
├── go1_21_hash.go
├── go1_21_hash_adler32.go
├── go1_21_hash_crc32.go
├── go1_21_hash_crc64.go
├── go1_21_hash_fnv.go
├── go1_21_hash_maphash.go
├── go1_21_html.go
├── go1_21_html_template.go
├── go1_21_image.go
├── go1_21_image_color.go
├── go1_21_image_color_palette.go
├── go1_21_image_draw.go
├── go1_21_image_gif.go
├── go1_21_image_jpeg.go
├── go1_21_image_png.go
├── go1_21_index_suffixarray.go
├── go1_21_io.go
├── go1_21_io_fs.go
├── go1_21_io_ioutil.go
├── go1_21_log.go
├── go1_21_log_slog.go
├── go1_21_log_syslog.go
├── go1_21_maps.go
├── go1_21_math.go
├── go1_21_math_big.go
├── go1_21_math_bits.go
├── go1_21_math_cmplx.go
├── go1_21_math_rand.go
├── go1_21_mime.go
├── go1_21_mime_multipart.go
├── go1_21_mime_quotedprintable.go
├── go1_21_net.go
├── go1_21_net_http.go
├── go1_21_net_http_cgi.go
├── go1_21_net_http_cookiejar.go
├── go1_21_net_http_fcgi.go
├── go1_21_net_http_httptest.go
├── go1_21_net_http_httptrace.go
├── go1_21_net_http_httputil.go
├── go1_21_net_http_pprof.go
├── go1_21_net_mail.go
├── go1_21_net_netip.go
├── go1_21_net_rpc.go
├── go1_21_net_rpc_jsonrpc.go
├── go1_21_net_smtp.go
├── go1_21_net_textproto.go
├── go1_21_net_url.go
├── go1_21_os.go
├── go1_21_os_signal.go
├── go1_21_os_user.go
├── go1_21_path.go
├── go1_21_path_filepath.go
├── go1_21_reflect.go
├── go1_21_regexp.go
├── go1_21_regexp_syntax.go
├── go1_21_runtime.go
├── go1_21_runtime_debug.go
├── go1_21_runtime_metrics.go
├── go1_21_runtime_pprof.go
├── go1_21_runtime_trace.go
├── go1_21_slices.go
├── go1_21_sort.go
├── go1_21_strconv.go
├── go1_21_strings.go
├── go1_21_sync.go
├── go1_21_sync_atomic.go
├── go1_21_testing.go
├── go1_21_testing_fstest.go
├── go1_21_testing_iotest.go
├── go1_21_testing_quick.go
├── go1_21_testing_slogtest.go
├── go1_21_text_scanner.go
├── go1_21_text_tabwriter.go
├── go1_21_text_template.go
├── go1_21_text_template_parse.go
├── go1_21_time.go
├── go1_21_unicode.go
├── go1_21_unicode_utf16.go
├── go1_21_unicode_utf8.go
├── go1_22_archive_tar.go
├── go1_22_archive_zip.go
├── go1_22_bufio.go
├── go1_22_bytes.go
├── go1_22_cmp.go
├── go1_22_compress_bzip2.go
├── go1_22_compress_flate.go
├── go1_22_compress_gzip.go
├── go1_22_compress_lzw.go
├── go1_22_compress_zlib.go
├── go1_22_container_heap.go
├── go1_22_container_list.go
├── go1_22_container_ring.go
├── go1_22_context.go
├── go1_22_crypto.go
├── go1_22_crypto_aes.go
├── go1_22_crypto_cipher.go
├── go1_22_crypto_des.go
├── go1_22_crypto_dsa.go
├── go1_22_crypto_ecdh.go
├── go1_22_crypto_ecdsa.go
├── go1_22_crypto_ed25519.go
├── go1_22_crypto_elliptic.go
├── go1_22_crypto_hmac.go
├── go1_22_crypto_md5.go
├── go1_22_crypto_rand.go
├── go1_22_crypto_rc4.go
├── go1_22_crypto_rsa.go
├── go1_22_crypto_sha1.go
├── go1_22_crypto_sha256.go
├── go1_22_crypto_sha512.go
├── go1_22_crypto_subtle.go
├── go1_22_crypto_tls.go
├── go1_22_crypto_x509.go
├── go1_22_crypto_x509_pkix.go
├── go1_22_database_sql.go
├── go1_22_database_sql_driver.go
├── go1_22_debug_buildinfo.go
├── go1_22_debug_dwarf.go
├── go1_22_debug_elf.go
├── go1_22_debug_gosym.go
├── go1_22_debug_macho.go
├── go1_22_debug_pe.go
├── go1_22_debug_plan9obj.go
├── go1_22_encoding.go
├── go1_22_encoding_ascii85.go
├── go1_22_encoding_asn1.go
├── go1_22_encoding_base32.go
├── go1_22_encoding_base64.go
├── go1_22_encoding_binary.go
├── go1_22_encoding_csv.go
├── go1_22_encoding_gob.go
├── go1_22_encoding_hex.go
├── go1_22_encoding_json.go
├── go1_22_encoding_pem.go
├── go1_22_encoding_xml.go
├── go1_22_errors.go
├── go1_22_expvar.go
├── go1_22_flag.go
├── go1_22_fmt.go
├── go1_22_go_ast.go
├── go1_22_go_build.go
├── go1_22_go_build_constraint.go
├── go1_22_go_constant.go
├── go1_22_go_doc.go
├── go1_22_go_doc_comment.go
├── go1_22_go_format.go
├── go1_22_go_importer.go
├── go1_22_go_parser.go
├── go1_22_go_printer.go
├── go1_22_go_scanner.go
├── go1_22_go_token.go
├── go1_22_go_types.go
├── go1_22_go_version.go
├── go1_22_hash.go
├── go1_22_hash_adler32.go
├── go1_22_hash_crc32.go
├── go1_22_hash_crc64.go
├── go1_22_hash_fnv.go
├── go1_22_hash_maphash.go
├── go1_22_html.go
├── go1_22_html_template.go
├── go1_22_image.go
├── go1_22_image_color.go
├── go1_22_image_color_palette.go
├── go1_22_image_draw.go
├── go1_22_image_gif.go
├── go1_22_image_jpeg.go
├── go1_22_image_png.go
├── go1_22_index_suffixarray.go
├── go1_22_io.go
├── go1_22_io_fs.go
├── go1_22_io_ioutil.go
├── go1_22_log.go
├── go1_22_log_slog.go
├── go1_22_log_syslog.go
├── go1_22_maps.go
├── go1_22_math.go
├── go1_22_math_big.go
├── go1_22_math_bits.go
├── go1_22_math_cmplx.go
├── go1_22_math_rand.go
├── go1_22_math_rand_v2.go
├── go1_22_mime.go
├── go1_22_mime_multipart.go
├── go1_22_mime_quotedprintable.go
├── go1_22_net.go
├── go1_22_net_http.go
├── go1_22_net_http_cgi.go
├── go1_22_net_http_cookiejar.go
├── go1_22_net_http_fcgi.go
├── go1_22_net_http_httptest.go
├── go1_22_net_http_httptrace.go
├── go1_22_net_http_httputil.go
├── go1_22_net_http_pprof.go
├── go1_22_net_mail.go
├── go1_22_net_netip.go
├── go1_22_net_rpc.go
├── go1_22_net_rpc_jsonrpc.go
├── go1_22_net_smtp.go
├── go1_22_net_textproto.go
├── go1_22_net_url.go
├── go1_22_os.go
├── go1_22_os_signal.go
├── go1_22_os_user.go
├── go1_22_path.go
├── go1_22_path_filepath.go
├── go1_22_reflect.go
├── go1_22_regexp.go
├── go1_22_regexp_syntax.go
├── go1_22_runtime.go
├── go1_22_runtime_debug.go
├── go1_22_runtime_metrics.go
├── go1_22_runtime_pprof.go
├── go1_22_runtime_trace.go
├── go1_22_slices.go
├── go1_22_sort.go
├── go1_22_strconv.go
├── go1_22_strings.go
├── go1_22_sync.go
├── go1_22_sync_atomic.go
├── go1_22_testing.go
├── go1_22_testing_fstest.go
├── go1_22_testing_iotest.go
├── go1_22_testing_quick.go
├── go1_22_testing_slogtest.go
├── go1_22_text_scanner.go
├── go1_22_text_tabwriter.go
├── go1_22_text_template.go
├── go1_22_text_template_parse.go
├── go1_22_time.go
├── go1_22_unicode.go
├── go1_22_unicode_utf16.go
├── go1_22_unicode_utf8.go
├── maptypes.go
├── restricted.go
├── stdlib-go1.22.go
├── stdlib.go
├── syscall/
│ ├── go1_21_syscall_aix_ppc64.go
│ ├── go1_21_syscall_android_386.go
│ ├── go1_21_syscall_android_amd64.go
│ ├── go1_21_syscall_android_arm.go
│ ├── go1_21_syscall_android_arm64.go
│ ├── go1_21_syscall_darwin_amd64.go
│ ├── go1_21_syscall_darwin_arm64.go
│ ├── go1_21_syscall_dragonfly_amd64.go
│ ├── go1_21_syscall_freebsd_386.go
│ ├── go1_21_syscall_freebsd_amd64.go
│ ├── go1_21_syscall_freebsd_arm.go
│ ├── go1_21_syscall_freebsd_arm64.go
│ ├── go1_21_syscall_freebsd_riscv64.go
│ ├── go1_21_syscall_illumos_amd64.go
│ ├── go1_21_syscall_ios_amd64.go
│ ├── go1_21_syscall_ios_arm64.go
│ ├── go1_21_syscall_js_wasm.go
│ ├── go1_21_syscall_linux_386.go
│ ├── go1_21_syscall_linux_amd64.go
│ ├── go1_21_syscall_linux_arm.go
│ ├── go1_21_syscall_linux_arm64.go
│ ├── go1_21_syscall_linux_loong64.go
│ ├── go1_21_syscall_linux_mips.go
│ ├── go1_21_syscall_linux_mips64.go
│ ├── go1_21_syscall_linux_mips64le.go
│ ├── go1_21_syscall_linux_mipsle.go
│ ├── go1_21_syscall_linux_ppc64.go
│ ├── go1_21_syscall_linux_ppc64le.go
│ ├── go1_21_syscall_linux_riscv64.go
│ ├── go1_21_syscall_linux_s390x.go
│ ├── go1_21_syscall_netbsd_386.go
│ ├── go1_21_syscall_netbsd_amd64.go
│ ├── go1_21_syscall_netbsd_arm.go
│ ├── go1_21_syscall_netbsd_arm64.go
│ ├── go1_21_syscall_openbsd_386.go
│ ├── go1_21_syscall_openbsd_amd64.go
│ ├── go1_21_syscall_openbsd_arm.go
│ ├── go1_21_syscall_openbsd_arm64.go
│ ├── go1_21_syscall_plan9_386.go
│ ├── go1_21_syscall_plan9_amd64.go
│ ├── go1_21_syscall_plan9_arm.go
│ ├── go1_21_syscall_solaris_amd64.go
│ ├── go1_21_syscall_wasip1_wasm.go
│ ├── go1_21_syscall_windows_386.go
│ ├── go1_21_syscall_windows_amd64.go
│ ├── go1_21_syscall_windows_arm.go
│ ├── go1_21_syscall_windows_arm64.go
│ ├── go1_22_syscall_aix_ppc64.go
│ ├── go1_22_syscall_android_386.go
│ ├── go1_22_syscall_android_amd64.go
│ ├── go1_22_syscall_android_arm.go
│ ├── go1_22_syscall_android_arm64.go
│ ├── go1_22_syscall_darwin_amd64.go
│ ├── go1_22_syscall_darwin_arm64.go
│ ├── go1_22_syscall_dragonfly_amd64.go
│ ├── go1_22_syscall_freebsd_386.go
│ ├── go1_22_syscall_freebsd_amd64.go
│ ├── go1_22_syscall_freebsd_arm.go
│ ├── go1_22_syscall_freebsd_arm64.go
│ ├── go1_22_syscall_freebsd_riscv64.go
│ ├── go1_22_syscall_illumos_amd64.go
│ ├── go1_22_syscall_ios_amd64.go
│ ├── go1_22_syscall_ios_arm64.go
│ ├── go1_22_syscall_js_wasm.go
│ ├── go1_22_syscall_linux_386.go
│ ├── go1_22_syscall_linux_amd64.go
│ ├── go1_22_syscall_linux_arm.go
│ ├── go1_22_syscall_linux_arm64.go
│ ├── go1_22_syscall_linux_loong64.go
│ ├── go1_22_syscall_linux_mips.go
│ ├── go1_22_syscall_linux_mips64.go
│ ├── go1_22_syscall_linux_mips64le.go
│ ├── go1_22_syscall_linux_mipsle.go
│ ├── go1_22_syscall_linux_ppc64.go
│ ├── go1_22_syscall_linux_ppc64le.go
│ ├── go1_22_syscall_linux_riscv64.go
│ ├── go1_22_syscall_linux_s390x.go
│ ├── go1_22_syscall_netbsd_386.go
│ ├── go1_22_syscall_netbsd_amd64.go
│ ├── go1_22_syscall_netbsd_arm.go
│ ├── go1_22_syscall_netbsd_arm64.go
│ ├── go1_22_syscall_openbsd_386.go
│ ├── go1_22_syscall_openbsd_amd64.go
│ ├── go1_22_syscall_openbsd_arm.go
│ ├── go1_22_syscall_openbsd_arm64.go
│ ├── go1_22_syscall_openbsd_ppc64.go
│ ├── go1_22_syscall_plan9_386.go
│ ├── go1_22_syscall_plan9_amd64.go
│ ├── go1_22_syscall_plan9_arm.go
│ ├── go1_22_syscall_solaris_amd64.go
│ ├── go1_22_syscall_wasip1_wasm.go
│ ├── go1_22_syscall_windows_386.go
│ ├── go1_22_syscall_windows_amd64.go
│ ├── go1_22_syscall_windows_arm.go
│ ├── go1_22_syscall_windows_arm64.go
│ └── syscall.go
├── unrestricted/
│ ├── go1_21_syscall_aix_ppc64.go
│ ├── go1_21_syscall_android_386.go
│ ├── go1_21_syscall_android_amd64.go
│ ├── go1_21_syscall_android_arm.go
│ ├── go1_21_syscall_android_arm64.go
│ ├── go1_21_syscall_darwin_amd64.go
│ ├── go1_21_syscall_darwin_arm64.go
│ ├── go1_21_syscall_dragonfly_amd64.go
│ ├── go1_21_syscall_freebsd_386.go
│ ├── go1_21_syscall_freebsd_amd64.go
│ ├── go1_21_syscall_freebsd_arm.go
│ ├── go1_21_syscall_freebsd_arm64.go
│ ├── go1_21_syscall_freebsd_riscv64.go
│ ├── go1_21_syscall_illumos_amd64.go
│ ├── go1_21_syscall_ios_amd64.go
│ ├── go1_21_syscall_ios_arm64.go
│ ├── go1_21_syscall_js_wasm.go
│ ├── go1_21_syscall_linux_386.go
│ ├── go1_21_syscall_linux_amd64.go
│ ├── go1_21_syscall_linux_arm.go
│ ├── go1_21_syscall_linux_arm64.go
│ ├── go1_21_syscall_linux_loong64.go
│ ├── go1_21_syscall_linux_mips.go
│ ├── go1_21_syscall_linux_mips64.go
│ ├── go1_21_syscall_linux_mips64le.go
│ ├── go1_21_syscall_linux_mipsle.go
│ ├── go1_21_syscall_linux_ppc64.go
│ ├── go1_21_syscall_linux_ppc64le.go
│ ├── go1_21_syscall_linux_riscv64.go
│ ├── go1_21_syscall_linux_s390x.go
│ ├── go1_21_syscall_netbsd_386.go
│ ├── go1_21_syscall_netbsd_amd64.go
│ ├── go1_21_syscall_netbsd_arm.go
│ ├── go1_21_syscall_netbsd_arm64.go
│ ├── go1_21_syscall_openbsd_386.go
│ ├── go1_21_syscall_openbsd_amd64.go
│ ├── go1_21_syscall_openbsd_arm.go
│ ├── go1_21_syscall_openbsd_arm64.go
│ ├── go1_21_syscall_plan9_386.go
│ ├── go1_21_syscall_plan9_amd64.go
│ ├── go1_21_syscall_plan9_arm.go
│ ├── go1_21_syscall_solaris_amd64.go
│ ├── go1_21_syscall_wasip1_wasm.go
│ ├── go1_21_syscall_windows_386.go
│ ├── go1_21_syscall_windows_amd64.go
│ ├── go1_21_syscall_windows_arm.go
│ ├── go1_21_syscall_windows_arm64.go
│ ├── go1_22_syscall_aix_ppc64.go
│ ├── go1_22_syscall_android_386.go
│ ├── go1_22_syscall_android_amd64.go
│ ├── go1_22_syscall_android_arm.go
│ ├── go1_22_syscall_android_arm64.go
│ ├── go1_22_syscall_darwin_amd64.go
│ ├── go1_22_syscall_darwin_arm64.go
│ ├── go1_22_syscall_dragonfly_amd64.go
│ ├── go1_22_syscall_freebsd_386.go
│ ├── go1_22_syscall_freebsd_amd64.go
│ ├── go1_22_syscall_freebsd_arm.go
│ ├── go1_22_syscall_freebsd_arm64.go
│ ├── go1_22_syscall_freebsd_riscv64.go
│ ├── go1_22_syscall_illumos_amd64.go
│ ├── go1_22_syscall_ios_amd64.go
│ ├── go1_22_syscall_ios_arm64.go
│ ├── go1_22_syscall_js_wasm.go
│ ├── go1_22_syscall_linux_386.go
│ ├── go1_22_syscall_linux_amd64.go
│ ├── go1_22_syscall_linux_arm.go
│ ├── go1_22_syscall_linux_arm64.go
│ ├── go1_22_syscall_linux_loong64.go
│ ├── go1_22_syscall_linux_mips.go
│ ├── go1_22_syscall_linux_mips64.go
│ ├── go1_22_syscall_linux_mips64le.go
│ ├── go1_22_syscall_linux_mipsle.go
│ ├── go1_22_syscall_linux_ppc64.go
│ ├── go1_22_syscall_linux_ppc64le.go
│ ├── go1_22_syscall_linux_riscv64.go
│ ├── go1_22_syscall_linux_s390x.go
│ ├── go1_22_syscall_netbsd_386.go
│ ├── go1_22_syscall_netbsd_amd64.go
│ ├── go1_22_syscall_netbsd_arm.go
│ ├── go1_22_syscall_netbsd_arm64.go
│ ├── go1_22_syscall_openbsd_386.go
│ ├── go1_22_syscall_openbsd_amd64.go
│ ├── go1_22_syscall_openbsd_arm.go
│ ├── go1_22_syscall_openbsd_arm64.go
│ ├── go1_22_syscall_openbsd_ppc64.go
│ ├── go1_22_syscall_plan9_386.go
│ ├── go1_22_syscall_plan9_amd64.go
│ ├── go1_22_syscall_plan9_arm.go
│ ├── go1_22_syscall_solaris_amd64.go
│ ├── go1_22_syscall_wasip1_wasm.go
│ ├── go1_22_syscall_windows_386.go
│ ├── go1_22_syscall_windows_amd64.go
│ ├── go1_22_syscall_windows_arm.go
│ ├── go1_22_syscall_windows_arm64.go
│ └── unrestricted.go
├── unsafe/
│ ├── go1_21_unsafe.go
│ ├── go1_22_unsafe.go
│ └── unsafe.go
└── wrapper-composed.go
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.yml
================================================
name: Bug Report
description: Create a report to help us improve
body:
- type: markdown
attributes:
value: |
⚠️ Make sure to browse the opened and closed issues before submit your issue.
- type: textarea
id: sample
attributes:
label: "The following program `sample.go` triggers an unexpected result"
value: |
package main
func main() {
// add a sample
}
render: go
validations:
required: true
- type: textarea
id: expected
attributes:
label: Expected result
description: |-
```console
$ go run ./sample.go
// output
```
placeholder: $ go run ./sample.go
render: console
validations:
required: true
- type: textarea
id: got
attributes:
label: Got
description: |-
```console
$ yaegi ./sample.go
// output
```
placeholder: $ yaegi ./sample.go
render: console
validations:
required: true
- type: input
id: version
attributes:
label: Yaegi Version
description: Can be a tag or a hash.
validations:
required: true
- type: textarea
id: additional
attributes:
label: Additional Notes
description: Use [Markdown syntax](https://help.github.com/articles/github-flavored-markdown) if needed.
validations:
required: false
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: false
contact_links:
- name: Questions
url: https://community.traefik.io/c/yaegi
about: If you have a question, or are looking for advice, please post on our discussions forum!
- name: Documentation
url: https://pkg.go.dev/github.com/traefik/yaegi
about: Please take a look to our documenation.
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.yml
================================================
name: Feature request
description: Propose a change to Yaegi
body:
- type: markdown
attributes:
value: |
⚠️ Make sure to browse the opened and closed issues before submit your issue.
- type: textarea
id: proposal
attributes:
label: Proposal
description: Write your feature request in the form of a proposal to be considered for implementation.
validations:
required: true
- type: textarea
id: background
attributes:
label: Background
description: Describe the background problem or need that led to this feature request.
validations:
required: true
- type: textarea
id: workarounds
attributes:
label: Workarounds
description: Are there any current workarounds that you're using that others in similar positions should know about?
validations:
required: true
================================================
FILE: .github/workflows/go-cross.yml
================================================
name: Build Cross OS
on:
push:
branches:
- master
pull_request:
jobs:
cross:
name: Go
runs-on: ${{ matrix.os }}
defaults:
run:
working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
strategy:
matrix:
go-version: [ oldstable, stable ]
os: [ubuntu-latest, macos-latest, windows-latest]
include:
- os: ubuntu-latest
go-path-suffix: /go
- os: macos-latest
go-path-suffix: /go
- os: windows-latest
go-path-suffix: \go
steps:
# https://github.com/marketplace/actions/checkout
- name: Checkout code
uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
with:
path: go/src/github.com/traefik/yaegi
# https://github.com/marketplace/actions/setup-go-environment
- name: Set up Go ${{ matrix.go-version }}
uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
with:
go-version: ${{ matrix.go-version }}
stable: true
- name: Setup GOPATH
run: go env -w GOPATH=${{ github.workspace }}${{ matrix.go-path-suffix }}
# TODO fail on windows
# - name: Tests
# run: go test -v -cover ./...
# env:
# GOPATH: ${{ github.workspace }}${{ matrix.go-path }}
- name: Build
run: go build -race -v -ldflags "-s -w" -trimpath
================================================
FILE: .github/workflows/main.yml
================================================
name: Main
on:
push:
branches:
- master
pull_request:
env:
GO_VERSION: stable
GOLANGCI_LINT_VERSION: v2.4.0
jobs:
linting:
name: Linting
runs-on: ubuntu-latest
steps:
- name: Check out code
uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
with:
fetch-depth: 0
- name: Set up Go ${{ env.GO_VERSION }}
uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
with:
go-version: ${{ env.GO_VERSION }}
- name: Check and get dependencies
run: |
go mod tidy
git diff --exit-code go.mod
# git diff --exit-code go.sum
go mod download
- name: Install golangci-lint ${{ env.GOLANGCI_LINT_VERSION }}
run: curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin ${GOLANGCI_LINT_VERSION}
- name: Run golangci-lint ${{ env.GOLANGCI_LINT_VERSION }}
run: make check
generate:
name: Checks code and generated code
runs-on: ubuntu-latest
needs: linting
strategy:
matrix:
go-version: [ oldstable, stable ]
steps:
- name: Check out code
uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
with:
fetch-depth: 0
- name: Set up Go ${{ matrix.go-version }}
uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
with:
go-version: ${{ matrix.go-version }}
stable: true
- name: Check generated code
run: |
rm -f interp/op.go
make generate
git update-index -q --refresh
CHANGED=$(git diff-index --name-only HEAD --)
test -z "$CHANGED" || echo $CHANGED
test -z "$CHANGED"
main:
name: Build and Test
runs-on: ubuntu-latest
needs: linting
defaults:
run:
working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
strategy:
matrix:
go-version: [ oldstable, stable ]
steps:
- name: Check out code
uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
with:
path: go/src/github.com/traefik/yaegi
fetch-depth: 0
- name: Set up Go ${{ matrix.go-version }}
uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
with:
go-version: ${{ matrix.go-version }}
stable: true
# https://github.com/marketplace/actions/cache
- name: Cache Go modules
uses: actions/cache@6f8efc29b200d32929f49075959781ed54ec270c # v3.5.0
with:
path: ./_test/tmp
key: ${{ runner.os }}-yaegi-${{ hashFiles('**//_test/tmp/') }}
restore-keys: |
${{ runner.os }}-yaegi-
- name: Setup GOPATH
run: go env -w GOPATH=${{ github.workspace }}/go
- name: Build
run: go build -v ./...
- name: Run tests
run: make tests
env:
GOPATH: ${{ github.workspace }}/go
================================================
FILE: .github/workflows/release.yml
================================================
name: Release
on:
push:
tags:
- v[0-9]+.[0-9]+*
env:
GO_VERSION: stable
jobs:
release:
name: Create a release
runs-on: ubuntu-latest
steps:
- name: Check out code
uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
with:
fetch-depth: 0
- name: Set up Go ${{ env.GO_VERSION }}
uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
with:
go-version: ${{ env.GO_VERSION }}
- name: Run GoReleaser
uses: goreleaser/goreleaser-action@5742e2a039330cbb23ebf35f046f814d4c6ff811 # v5.1.0
with:
version: latest
args: release --clean
env:
GITHUB_TOKEN: ${{ secrets.GH_TOKEN_REPO }}
================================================
FILE: .gitignore
================================================
.*.swo
.*.swp
*.dot
*.out
.idea/
/yaegi
internal/cmd/extract/extract
example/inception/inception
_test/tmp/
/dist
================================================
FILE: .golangci.yml
================================================
version: "2"
linters:
default: standard
enable:
- depguard
- goconst
- godot
- grouper
- misspell
- perfsprint
- thelper
- unconvert
- unparam
disable:
- errcheck
settings:
depguard:
rules:
main:
files:
- $all
allow:
- $gostd
- github.com/traefik/yaegi
goconst:
min-len: 3
min-occurrences: 3
misspell:
locale: US
staticcheck:
checks: ["all", "-ST1000", "-ST1023", "-QF1001", "-QF1008", "-QF1011"]
exclusions:
generated: lax
rules:
- linters:
- goconst
path: .+_test\.go
- path: .+_test\.go
text: 'var-declaration:'
- path: interp/interp.go
text: '`in` can be `io.Reader`'
- path: interp/interp.go
text: '`out` can be `io.Writer`'
- path: interp/interp.go
text: '`Panic` should conform to the `XxxError` format'
- linters:
- thelper
path: interp/interp_eval_test.go
- linters:
- containedctx
path: interp/debugger.go
- path: (.+)\.go$
text: fmt.Sprintf can be replaced with string
paths:
- third_party$
- builtin$
- examples$
issues:
max-issues-per-linter: 0
max-same-issues: 0
formatters:
enable:
- gci
- gofmt
- gofumpt
- goimports
exclusions:
generated: lax
paths:
- third_party$
- builtin$
- examples$
================================================
FILE: .goreleaser.yml
================================================
project_name: yaegi
builds:
- id: yaegi
binary: yaegi
main: ./cmd/yaegi/
goos:
- darwin
- linux
# - windows
- freebsd
- openbsd
- solaris
goarch:
- amd64
- 386
- arm
- arm64
goarm:
- 7
- 6
- 5
ignore:
- goos: darwin
goarch: 386
changelog:
sort: asc
filters:
exclude:
- '^docs:'
- '^doc:'
- '^chore:'
- '^test:'
- '^tests:'
archives:
- id: archive
name_template: '{{ .ProjectName }}_v{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
format: tar.gz
format_overrides:
- goos: windows
format: zip
files:
- LICENSE
brews:
- repository:
owner: traefik
name: homebrew-tap
commit_author:
name: traefiker
email: 30906710+traefiker@users.noreply.github.com
folder: Formula
homepage: https://github.com/traefik/yaegi
description: |
Yaegi is Another Elegant Go Interpreter.
It powers executable Go scripts and plugins, in embedded interpreters
or interactive shells, on top of the Go runtime.
test: |
system "#{bin}/yaegi version"
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing
Yaegi is an open source project, and your feedback and contributions
are needed and always welcome.
[Issues] and [Pull Requests] are opened at https://github.com/traefik/yaegi.
Non trivial changes should be discussed with the project maintainers by
opening a [Feature Request] clearly explaining rationale, background
and possible implementation ideas. Feel free to provide code in such
discussions.
Once the proposal is approved, a Pull Request can be opened. If you want
to provide early visibility to reviewers, create a [Draft Pull Request].
We will also require you to sign the [Traefik Contributor License Agreement]
after you submit your first pull request to this project. The link to sign the
agreement will be presented to you in the web interface of the pull request.
[Issues]: https://github.com/traefik/yaegi/issues
[Pull Requests]: https://github.com/traefik/yaegi/issues
[Feature Request]: https://github.com/traefik/yaegi/issues/new?template=feature_request.md
[Draft Pull Request]: https://github.blog/2019-02-14-introducing-draft-pull-requests/
[Traefik Labs Contributor License Agreement]: https://cla-assistant.io/traefik/yaegi
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2019 Containous SAS
Copyright 2020 Traefik Labs SAS
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: Makefile
================================================
# Static linting of source files. See .golangci.toml for options
check:
golangci-lint run
# Generate stdlib/syscall/syscall_GOOS_GOARCH.go for all platforms
gen_all_syscall: internal/cmd/extract/extract
@for v in $$(go tool dist list); do \
echo syscall_$${v%/*}_$${v#*/}.go; \
GOOS=$${v%/*} GOARCH=$${v#*/} go generate ./stdlib/syscall ./stdlib/unrestricted; \
done
internal/cmd/extract/extract:
rm -f internal/cmd/extract/extract
go generate ./internal/cmd/extract
generate: gen_all_syscall
go generate
install:
GOFLAGS=-ldflags=-X=main.version=$$(git describe --tags) go install ./...
tests:
go test -v ./...
go test -race ./interp
# https://github.com/goreleaser/godownloader
install.sh: .goreleaser.yml
godownloader --repo=traefik/yaegi -o install.sh .goreleaser.yml
generic_list = cmp/cmp.go slices/slices.go slices/sort.go slices/zsortanyfunc.go maps/maps.go \
sync/oncefunc.go sync/atomic/type.go
# get_generic_src imports stdlib files containing generic symbols definitions
get_generic_src:
eval "`go env`"; echo $$GOROOT; gov=$${GOVERSION#*.}; gov=$${gov%.*}; \
for f in ${generic_list}; do \
nf=stdlib/generic/go1_$${gov}_`echo $$f | tr / _`.txt; echo "nf: $$nf"; \
cat "$$GOROOT/src/$$f" > "$$nf"; \
done
.PHONY: check gen_all_syscall internal/cmd/extract/extract get_generic_src install
================================================
FILE: README.md
================================================
<p align="center">
<img width="400" src="doc/images/yaegi.png" alt="Yaegi" title="Yaegi" />
</p>
[](https://github.com/traefik/yaegi/releases)
[](https://github.com/traefik/yaegi/actions/workflows/main.yml)
[](https://pkg.go.dev/mod/github.com/traefik/yaegi)
Yaegi is Another Elegant Go Interpreter.
It powers executable Go scripts and plugins, in embedded interpreters or interactive shells, on top of the Go runtime.
## Features
* Complete support of [Go specification][specs]
* Written in pure Go, using only the standard library
* Simple interpreter API: `New()`, `Eval()`, `Use()`
* Works everywhere Go works
* All Go & runtime resources accessible from script (with control)
* Security: `unsafe` and `syscall` packages neither used nor exported by default
* Support the latest 2 major releases of Go (Go 1.21 and Go 1.22)
## Install
### Go package
```go
import "github.com/traefik/yaegi/interp"
```
### Command-line executable
```bash
go install github.com/traefik/yaegi/cmd/yaegi@latest
```
Note that you can use [rlwrap](https://github.com/hanslub42/rlwrap) (install with your favorite package manager),
and alias the `yaegi` command in `alias yaegi='rlwrap yaegi'` in your `~/.bashrc`, to have history and command line edition.
### CI Integration
```bash
curl -sfL https://raw.githubusercontent.com/traefik/yaegi/master/install.sh | bash -s -- -b $GOPATH/bin v0.9.0
```
## Usage
### As an embedded interpreter
Create an interpreter with `New()`, run Go code with `Eval()`:
```go
package main
import (
"github.com/traefik/yaegi/interp"
"github.com/traefik/yaegi/stdlib"
)
func main() {
i := interp.New(interp.Options{})
i.Use(stdlib.Symbols)
_, err := i.Eval(`import "fmt"`)
if err != nil {
panic(err)
}
_, err = i.Eval(`fmt.Println("Hello Yaegi")`)
if err != nil {
panic(err)
}
}
```
[Go Playground](https://play.golang.org/p/2n-EpZbMYI9)
### As a dynamic extension framework
The following program is compiled ahead of time, except `bar()` which is interpreted, with the following steps:
1. use of `i.Eval(src)` to evaluate the script in the context of interpreter
2. use of `v, err := i.Eval("foo.Bar")` to get the symbol from the interpreter context, as a `reflect.Value`
3. application of `Interface()` method and type assertion to convert `v` into `bar`, as if it was compiled
```go
package main
import "github.com/traefik/yaegi/interp"
const src = `package foo
func Bar(s string) string { return s + "-Foo" }`
func main() {
i := interp.New(interp.Options{})
_, err := i.Eval(src)
if err != nil {
panic(err)
}
v, err := i.Eval("foo.Bar")
if err != nil {
panic(err)
}
bar := v.Interface().(func(string) string)
r := bar("Kung")
println(r)
}
```
[Go Playground](https://play.golang.org/p/WvwH4JqrU-p)
### As a command-line interpreter
The Yaegi command can run an interactive Read-Eval-Print-Loop:
```console
$ yaegi
> 1 + 2
3
> import "fmt"
> fmt.Println("Hello World")
Hello World
>
```
Note that in interactive mode, all stdlib package are pre-imported,
you can use them directly:
```console
$ yaegi
> reflect.TypeOf(time.Date)
: func(int, time.Month, int, int, int, int, int, *time.Location) time.Time
>
```
Or interpret Go packages, directories or files, including itself:
```console
$ yaegi -syscall -unsafe -unrestricted github.com/traefik/yaegi/cmd/yaegi
>
```
Or for Go scripting in the shebang line:
```console
$ cat /tmp/test
#!/usr/bin/env yaegi
package main
import "fmt"
func main() {
fmt.Println("test")
}
$ ls -la /tmp/test
-rwxr-xr-x 1 dow184 dow184 93 Jan 6 13:38 /tmp/test
$ /tmp/test
test
```
## Documentation
Documentation about Yaegi commands and libraries can be found at usual [godoc.org][docs].
Key documentation of the internal design: https://marc.vertes.org/yaegi-internals/ Also see [interp/trace.go](interp/trace.go) for helpful printing commands to see what is happening under the hood during compilation.
## Limitations
Beside the known [bugs] which are supposed to be fixed in the short term, there are some limitations not planned to be addressed soon:
- Assembly files (`.s`) are not supported.
- Calling C code is not supported (no virtual "C" package).
- Directives about the compiler, the linker, or embedding files are not supported.
- Interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers.
- Representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode.
- Interpreting computation intensive code is likely to remain significantly slower than in compiled mode.
Go modules are not supported yet. Until that, it is necessary to install the source into `$GOPATH/src/github.com/traefik/yaegi` to pass all the tests.
## Contributing
[Contributing guide](CONTRIBUTING.md).
## License
[Apache 2.0][License].
[specs]: https://golang.org/ref/spec
[docs]: https://pkg.go.dev/github.com/traefik/yaegi
[license]: https://github.com/traefik/yaegi/blob/master/LICENSE
[github]: https://github.com/traefik/yaegi
[bugs]: https://github.com/traefik/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug
================================================
FILE: _test/a1.go
================================================
package main
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
println(a[1]) // 2
for i, v := range a {
println(v)
if i == 3 {
break
}
}
}
// Output:
// 2
// 1
// 2
// 3
// 4
================================================
FILE: _test/a10.go
================================================
package main
type Sample struct {
Name string
}
var samples = []Sample{}
func f(i int) {
println(samples[i].Name)
}
func main() {
samples = append(samples, Sample{Name: "test"})
f(0)
}
// Output:
// test
================================================
FILE: _test/a11.go
================================================
package main
func main() {
a := []int{1, 2, 3, 4}
for _, v := range a {
println(v)
}
}
// Output:
// 1
// 2
// 3
// 4
================================================
FILE: _test/a12.go
================================================
package main
import "fmt"
func main() {
var buf [12]int
fmt.Println(buf[0])
}
// Output:
// 0
================================================
FILE: _test/a13.go
================================================
package main
type T1 struct {
num []int
}
func main() {
a := T1{[]int{1, 3, 5}}
for i, v := range a.num {
println(i, v)
}
}
// Output:
// 0 1
// 1 3
// 2 5
================================================
FILE: _test/a14.go
================================================
package main
import "fmt"
const size = 12
func main() {
var buf [size]int
fmt.Println(buf)
}
// Output:
// [0 0 0 0 0 0 0 0 0 0 0 0]
================================================
FILE: _test/a15.go
================================================
package main
import "fmt"
const size = 12
func main() {
var buf [size]int
fmt.Println(buf[:])
}
// Output:
// [0 0 0 0 0 0 0 0 0 0 0 0]
================================================
FILE: _test/a16.go
================================================
package main
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
println(a[1]) // 2
for k := 0; k < 2; k++ {
for i, v := range a {
println(v)
if i == 3 {
break
}
}
}
}
// Output:
// 2
// 1
// 2
// 3
// 4
// 1
// 2
// 3
// 4
================================================
FILE: _test/a17.go
================================================
package main
import "fmt"
func main() {
a := make([]int, 2, 7)
fmt.Println(a, len(a), cap(a))
}
// Output:
// [0 0] 2 7
================================================
FILE: _test/a18.go
================================================
package main
func main() {
a := []int64{1, 2, 3, 4}
for _, v := range a {
println(v)
}
}
// Output:
// 1
// 2
// 3
// 4
================================================
FILE: _test/a19.go
================================================
package main
func main() {
var buf [bsize]byte
println(len(buf))
}
const bsize = 10
// Output:
// 10
================================================
FILE: _test/a2.go
================================================
package main
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
a[1] = 5
println(a[1]) // 2
for i, v := range a {
println(v)
if i == 3 {
break
}
}
}
// Output:
// 5
// 1
// 5
// 3
// 4
================================================
FILE: _test/a20.go
================================================
package main
import "fmt"
type IntArray []int
func (h *IntArray) Add(x int) {
*h = append(*h, x)
}
func main() {
a := IntArray{}
a.Add(4)
fmt.Println(a)
}
// Output:
// [4]
================================================
FILE: _test/a21.go
================================================
package main
import "fmt"
func main() {
a := []byte("hello")
fmt.Println(a)
a = append(a, '=')
fmt.Println(a)
}
// Output:
// [104 101 108 108 111]
// [104 101 108 108 111 61]
================================================
FILE: _test/a22.go
================================================
package main
func main() {
a := [256]int{}
var b uint8 = 12
a[b] = 1
println(a[b])
}
// Output:
// 1
================================================
FILE: _test/a23.go
================================================
package main
import "fmt"
func main() {
var key, salt [32]byte
for i := range key {
key[i] = byte(i)
salt[i] = byte(i + 32)
}
fmt.Println(key)
fmt.Println(salt)
}
// Output:
// [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31]
// [32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63]
================================================
FILE: _test/a24.go
================================================
package main
import "fmt"
func main() {
for i := 0; i < 2; i++ {
var buf [8]byte
var x int
fmt.Println(buf, x)
for i := range buf {
buf[i] = byte(i)
x = i
}
fmt.Println(buf, x)
}
}
// Output:
// [0 0 0 0 0 0 0 0] 0
// [0 1 2 3 4 5 6 7] 7
// [0 0 0 0 0 0 0 0] 0
// [0 1 2 3 4 5 6 7] 7
================================================
FILE: _test/a25.go
================================================
package main
import "fmt"
func main() {
var buf [8]byte
for i := 0; i < 2; i++ {
for i := range buf {
buf[i] += byte(i)
}
fmt.Println(buf)
}
}
// Output:
// [0 1 2 3 4 5 6 7]
// [0 2 4 6 8 10 12 14]
================================================
FILE: _test/a26.go
================================================
package main
func main() {
a := [3]int{1, 2, 3}
b := [3]int{1, 2, 3}
println(a == b)
}
// Output:
// true
================================================
FILE: _test/a27.go
================================================
package main
import "fmt"
func main() {
a := [...]string{"hello", "world"}
fmt.Printf("%v %T\n", a, a)
}
// Output:
// [hello world] [2]string
================================================
FILE: _test/a28.go
================================================
package main
import "fmt"
func main() {
a := [...]string{9: "hello"}
fmt.Printf("%v %T\n", a, a)
}
// Output:
// [ hello] [10]string
================================================
FILE: _test/a29.go
================================================
package main
import "fmt"
const (
zero = iota
one
two
three
)
func main() {
a := [...]string{
zero: "zero",
one: "one",
three: "three",
three + 2: "five",
}
fmt.Printf("%v %T\n", a, a)
}
// Output:
// [zero one three five] [6]string
================================================
FILE: _test/a3.go
================================================
package main
import "fmt"
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
fmt.Println(a[2:])
}
// Output:
// [3 4 5 6]
================================================
FILE: _test/a30.go
================================================
package main
func main() {
for range []struct{}{} {
}
println("ok")
}
// Output:
// ok
================================================
FILE: _test/a31.go
================================================
package main
func main() {
for range []int{0, 1, 2} {
print("hello ")
}
println("")
}
// Output:
// hello hello hello
================================================
FILE: _test/a32.go
================================================
package main
import "fmt"
type T struct{}
var a = []T{{}}
func main() {
fmt.Println(a)
}
// Output:
// [{}]
================================================
FILE: _test/a33.go
================================================
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3}
b := a
fmt.Println(b)
}
// Output:
// [1 2 3]
================================================
FILE: _test/a34.go
================================================
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3}
var b [3]int = a
fmt.Println(b)
}
// Output:
// [1 2 3]
================================================
FILE: _test/a35.go
================================================
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3}
b := a
b[0] = -1
fmt.Println(a)
}
// Output:
// [1 2 3]
================================================
FILE: _test/a36.go
================================================
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3}
var b [3]int = a
b[0] = -1
fmt.Println(a)
}
// Output:
// [1 2 3]
================================================
FILE: _test/a37.go
================================================
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3}
fmt.Println(a)
}
// Output:
// [1 2 3]
================================================
FILE: _test/a38.go
================================================
package main
import "fmt"
func main() {
a := [...]byte{}
fmt.Printf("%T\n", a)
}
// Output:
// [0]uint8
================================================
FILE: _test/a39.go
================================================
package main
import "fmt"
func main() {
a := [...]byte{}
b := a
fmt.Printf("%T %T\n", a, b)
}
// Output:
// [0]uint8 [0]uint8
================================================
FILE: _test/a4.go
================================================
package main
import "fmt"
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
fmt.Println(a[2:4])
}
// Output:
// [3 4]
================================================
FILE: _test/a40.go
================================================
package main
import "fmt"
type rule uint8
const (
r0 rule = iota
r1
r2
)
var a = [...]int{
r0: 1,
r1: 12,
}
func main() {
fmt.Println(a)
}
// Output:
// [1 12]
================================================
FILE: _test/a41.go
================================================
package main
var a = [...]bool{true, true}
func main() {
println(a[0] && true)
}
// Output:
// true
================================================
FILE: _test/a42.go
================================================
package main
import (
"encoding/binary"
"fmt"
)
func main() {
var b [8]byte
binary.LittleEndian.PutUint64(b[:], uint64(1))
fmt.Println(b)
}
// Output:
// [1 0 0 0 0 0 0 0]
================================================
FILE: _test/a43.go
================================================
package main
import "fmt"
type T [l1 + l2]int
const (
l1 = 2
l2 = 3
)
func main() {
fmt.Println(T{})
}
// Output:
// [0 0 0 0 0]
================================================
FILE: _test/a44.go
================================================
package main
var a = [max]int{}
const max = 32
func main() {
println(len(a))
}
// Output:
// 32
================================================
FILE: _test/a5.go
================================================
package main
import "fmt"
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
fmt.Println(a[:4])
}
// Output:
// [1 2 3 4]
================================================
FILE: _test/a6.go
================================================
package main
import "fmt"
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
fmt.Println(a[:])
}
// Output:
// [1 2 3 4 5 6]
================================================
FILE: _test/a7.go
================================================
package main
import "fmt"
func main() {
a := [6]int{1, 2, 3, 4, 5, 6}
fmt.Println(len(a))
}
// Output:
// 6
================================================
FILE: _test/a8.go
================================================
package main
import "fmt"
func main() {
//a := []int{1, 2}
a := make([]int, 2)
//a[0] = 1
//a[1] = 2
fmt.Println(a)
}
// Output:
// [0 0]
================================================
FILE: _test/a9.go
================================================
package main
import "fmt"
//var (
// samples = []int{}
// b = 1
//)
func main() {
var samples = []int{}
samples = append(samples, 1)
fmt.Println(samples)
}
// Output:
// [1]
================================================
FILE: _test/add0.go
================================================
package main
func main() {
var a interface{} = 2 + 5
println(a.(int))
}
// Output:
// 7
================================================
FILE: _test/add1.go
================================================
package main
func main() {
b := 2 // int
var c int = 5 + b
println(c)
var d int32 = 6 + int32(b)
println(d)
var a interface{} = 7 + b
println(a.(int))
var e int32 = 2
var f interface{} = 8 + e
println(f.(int32))
a = 9 + e
println(a.(int32))
var g int = 2
a = 10 + g
println(a.(int))
// multiple assignment
var foo interface{}
foo, a = "hello", 11 + g
println(a.(int))
println(foo.(string))
}
// Output:
// 7
// 8
// 9
// 10
// 11
// 12
// 13
// hello
================================================
FILE: _test/add2.go
================================================
package main
type iface interface{}
func main() {
b := 2
var a iface = 5 + b
println(a.(int))
}
// Output:
// 7
================================================
FILE: _test/addr0.go
================================================
package main
import (
"fmt"
"net/http"
)
type extendedRequest struct {
http.Request
Data string
}
func main() {
r := extendedRequest{}
req := &r.Request
fmt.Printf("%T\n", r.Request)
fmt.Printf("%T\n", req)
}
// Output:
// http.Request
// *http.Request
================================================
FILE: _test/addr1.go
================================================
package main
import "fmt"
type T struct {
A int
B int
}
func main() {
a := &[]T{
{1, 2},
{3, 4},
}
fmt.Println("a:", a)
x := &(*a)[1:][0]
fmt.Println("x:", x)
}
// Output:
// a: &[{1 2} {3 4}]
// x: &{3 4}
================================================
FILE: _test/addr2.go
================================================
package main
import (
"encoding/xml"
"errors"
"fmt"
)
type Email struct {
Where string `xml:"where,attr"`
Addr string
}
func f(r interface{}) error {
return withPointerAsInterface(&r)
}
func withPointerAsInterface(r interface{}) error {
_ = (r).(*interface{})
rp, ok := (r).(*interface{})
if !ok {
return errors.New("cannot assert to *interface{}")
}
em, ok := (*rp).(*Email)
if !ok {
return errors.New("cannot assert to *Email")
}
em.Where = "work"
em.Addr = "bob@work.com"
return nil
}
func ff(s string, r interface{}) error {
return xml.Unmarshal([]byte(s), r)
}
func fff(s string, r interface{}) error {
return xml.Unmarshal([]byte(s), &r)
}
func main() {
data := `
<Email where='work'>
<Addr>bob@work.com</Addr>
</Email>
`
v := Email{}
err := f(&v)
fmt.Println(err, v)
vv := Email{}
err = ff(data, &vv)
fmt.Println(err, vv)
vvv := Email{}
err = ff(data, &vvv)
fmt.Println(err, vvv)
}
// Output:
// <nil> {work bob@work.com}
// <nil> {work bob@work.com}
// <nil> {work bob@work.com}
================================================
FILE: _test/addr3.go
================================================
package main
import (
"fmt"
)
func main() {
var a interface{}
a = 2
fmt.Println(a)
var b *interface{}
b = &a
fmt.Println(*b)
var c **interface{}
c = &b
fmt.Println(**c)
}
// Output:
// 2
// 2
// 2
================================================
FILE: _test/addr4.go
================================================
package main
import (
"encoding/json"
"fmt"
"log"
)
const jsonData = `[
"foo",
"bar"
]`
const jsonData2 = `[
{"foo": "foo"},
{"bar": "bar"}
]`
const jsonData3 = `{
"foo": "foo",
"bar": "bar"
}`
func fromSlice() {
var a []interface{}
var c, d interface{}
c = 2
d = 3
a = []interface{}{c, d}
if err := json.Unmarshal([]byte(jsonData), &a); err != nil {
log.Fatalln(err)
}
for k, v := range a {
fmt.Println(k, ":", v)
}
}
func fromEmpty() {
var a interface{}
var c, d interface{}
c = 2
d = 3
a = []interface{}{c, d}
if err := json.Unmarshal([]byte(jsonData), &a); err != nil {
log.Fatalln(err)
}
b := a.([]interface{})
for k, v := range b {
fmt.Println(k, ":", v)
}
}
func sliceOfObjects() {
var a interface{}
if err := json.Unmarshal([]byte(jsonData2), &a); err != nil {
log.Fatalln(err)
}
b := a.([]interface{})
for k, v := range b {
fmt.Println(k, ":", v)
}
}
func intoMap() {
var a interface{}
if err := json.Unmarshal([]byte(jsonData3), &a); err != nil {
log.Fatalln(err)
}
b := a.(map[string]interface{})
seenFoo := false
for k, v := range b {
vv := v.(string)
if vv != "foo" {
if seenFoo {
fmt.Println(k, ":", vv)
break
}
kk := k
vvv := vv
defer fmt.Println(kk, ":", vvv)
continue
}
seenFoo = true
fmt.Println(k, ":", vv)
}
}
func main() {
fromSlice()
fromEmpty()
sliceOfObjects()
intoMap()
}
// Output:
// 0 : foo
// 1 : bar
// 0 : foo
// 1 : bar
// 0 : map[foo:foo]
// 1 : map[bar:bar]
// foo : foo
// bar : bar
================================================
FILE: _test/addr5.go
================================================
package main
import (
"encoding/json"
"fmt"
"net/url"
)
func main() {
body := []byte(`{
"BODY_1": "VALUE_1",
"BODY_2": "VALUE_2",
"BODY_3": null,
"BODY_4": {
"BODY_1": "VALUE_1",
"BODY_2": "VALUE_2",
"BODY_3": null
},
"BODY_5": [
"VALUE_1",
"VALUE_2",
"VALUE_3"
]
}`)
values := url.Values{}
var rawData map[string]interface{}
err := json.Unmarshal(body, &rawData)
if err != nil {
fmt.Println("can't parse body")
return
}
for key, val := range rawData {
switch val.(type) {
case string, bool, float64:
values.Add(key, fmt.Sprint(val))
case nil:
values.Add(key, "")
case map[string]interface{}, []interface{}:
jsonVal, err := json.Marshal(val)
if err != nil {
fmt.Println("can't encode json")
return
}
values.Add(key, string(jsonVal))
}
}
fmt.Println(values.Get("BODY_1"))
fmt.Println(values.Get("BODY_2"))
fmt.Println(values.Get("BODY_3"))
fmt.Println(values.Get("BODY_4"))
fmt.Println(values.Get("BODY_5"))
}
// Output:
// VALUE_1
// VALUE_2
//
// {"BODY_1":"VALUE_1","BODY_2":"VALUE_2","BODY_3":null}
// ["VALUE_1","VALUE_2","VALUE_3"]
================================================
FILE: _test/and.go
================================================
package main
func main() {
a, b := 1, 2
if f1() && f2() {
println(a, b)
}
}
func f1() bool {
println("f1")
//return true
return 0 == 0
}
func f2() bool {
println("f2")
//return false
return 1 == 0
}
// Output:
// f1
// f2
================================================
FILE: _test/and0.go
================================================
package main
func main() {
a, b := 1, 2
if f2() && f1() {
println(a, b)
}
}
func f1() bool {
println("f1")
return true
}
func f2() bool {
println("f2")
return false
}
// Output:
// f2
================================================
FILE: _test/and1.go
================================================
package main
func main() {
a := f2() && f1()
println(a)
}
func f1() bool {
println("f1")
return true
}
func f2() bool {
println("f2")
return false
}
// Output:
// f2
// false
================================================
FILE: _test/and2.go
================================================
package main
func f() bool {
println("in f")
return true
}
func main() {
var (
cl = 0
ct = "some text"
ce = ""
)
if ce == "" && (cl == 0 || cl > 1000) && (ct == "" || f()) {
println("ok")
}
}
// Output:
// in f
// ok
================================================
FILE: _test/and3.go
================================================
package main
var a = true && true
func main() {
println(a)
}
// Output:
// true
================================================
FILE: _test/append0.go
================================================
package main
import "fmt"
func f(a []int, b int) interface{} { return append(a, b) }
func main() {
a := []int{1, 2}
r := f(a, 3)
fmt.Println(r.([]int))
}
// Output:
// [1 2 3]
================================================
FILE: _test/append1.go
================================================
package main
import (
"bufio"
"bytes"
)
func main() {
s := bufio.NewScanner(bytes.NewReader([]byte("Hello\nTest\nLine3")))
s.Scan()
println(string(append(s.Bytes(), []byte(" World")...)))
}
// Output:
// Hello World
================================================
FILE: _test/append2.go
================================================
package main
import (
"bufio"
"bytes"
)
func main() {
s := bufio.NewScanner(bytes.NewReader([]byte("Hello\nTest\nLine3")))
s.Scan()
println(string(append(s.Bytes(), " World"...)))
}
// Output:
// Hello World
================================================
FILE: _test/append3.go
================================================
package main
import "fmt"
func main() {
a := []int{1, 2}
b := [2]int{3, 4}
fmt.Println(append(a, b[:]...))
fmt.Println(append(a, []int{5, 6}...))
}
// Output:
// [1 2 3 4]
// [1 2 5 6]
================================================
FILE: _test/append4.go
================================================
package main
import "fmt"
func main() {
a := []*int{}
a = append(a, nil)
fmt.Println(a)
}
// Output:
// [<nil>]
================================================
FILE: _test/assert0.go
================================================
package main
import (
"fmt"
"time"
)
type MyWriter interface {
Write(p []byte) (i int, err error)
}
type DummyWriter interface {
Write(p []byte) (i int, err error)
}
type TestStruct struct{}
func (t TestStruct) Write(p []byte) (n int, err error) {
return len(p), nil
}
func usesWriter(w MyWriter) {
n, _ := w.Write([]byte("hello world"))
fmt.Println(n)
}
type MyStringer interface {
String() string
}
type DummyStringer interface {
String() string
}
func usesStringer(s MyStringer) {
fmt.Println(s.String())
}
func main() {
// TODO(mpl): restore when we can deal with empty interface.
// var t interface{}
var t DummyWriter
t = TestStruct{}
var tw MyWriter
var ok bool
tw, ok = t.(MyWriter)
if !ok {
fmt.Println("TestStruct does not implement MyWriter")
} else {
fmt.Println("TestStruct implements MyWriter")
usesWriter(tw)
}
n, _ := t.(MyWriter).Write([]byte("hello world"))
fmt.Println(n)
// not redundant with the above, because it goes through a slightly different code path.
if _, ok := t.(MyWriter); !ok {
fmt.Println("TestStruct does not implement MyWriter")
return
} else {
fmt.Println("TestStruct implements MyWriter")
}
// TODO(mpl): restore
/*
t = 42
foo, ok := t.(MyWriter)
if !ok {
fmt.Println("42 does not implement MyWriter")
} else {
fmt.Println("42 implements MyWriter")
}
_ = foo
if _, ok := t.(MyWriter); !ok {
fmt.Println("42 does not implement MyWriter")
} else {
fmt.Println("42 implements MyWriter")
}
*/
// var tt interface{}
var tt DummyStringer
tt = time.Nanosecond
var myD MyStringer
myD, ok = tt.(MyStringer)
if !ok {
fmt.Println("time.Nanosecond does not implement MyStringer")
} else {
fmt.Println("time.Nanosecond implements MyStringer")
usesStringer(myD)
}
fmt.Println(tt.(MyStringer).String())
if _, ok := tt.(MyStringer); !ok {
fmt.Println("time.Nanosecond does not implement MyStringer")
} else {
fmt.Println("time.Nanosecond implements MyStringer")
}
// TODO(mpl): restore
/*
tt = 42
bar, ok := tt.(MyStringer)
if !ok {
fmt.Println("42 does not implement MyStringer")
} else {
fmt.Println("42 implements MyStringer")
}
_ = bar
if _, ok := tt.(MyStringer); !ok {
fmt.Println("42 does not implement MyStringer")
} else {
fmt.Println("42 implements MyStringer")
}
*/
}
// Output:
// TestStruct implements MyWriter
// 11
// 11
// TestStruct implements MyWriter
// time.Nanosecond implements MyStringer
// 1ns
// 1ns
// time.Nanosecond implements MyStringer
================================================
FILE: _test/assert1.go
================================================
package main
import (
"fmt"
"reflect"
"time"
)
type TestStruct struct{}
func (t TestStruct) String() string {
return "hello world"
}
type DummyStringer interface{
String() string
}
func main() {
aType := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
var t interface{}
t = time.Nanosecond
s, ok := t.(fmt.Stringer)
if !ok {
fmt.Println("time.Nanosecond does not implement fmt.Stringer")
return
}
fmt.Println(s.String())
fmt.Println(t.(fmt.Stringer).String())
bType := reflect.TypeOf(time.Nanosecond)
fmt.Println(bType.Implements(aType))
// not redundant with the above, because it goes through a slightly different code path.
if _, ok := t.(fmt.Stringer); !ok {
fmt.Println("time.Nanosecond does not implement fmt.Stringer")
return
} else {
fmt.Println("time.Nanosecond implements fmt.Stringer")
}
t = 42
foo, ok := t.(fmt.Stringer)
if !ok {
fmt.Println("42 does not implement fmt.Stringer")
} else {
fmt.Println("42 implements fmt.Stringer")
return
}
_ = foo
if _, ok := t.(fmt.Stringer); !ok {
fmt.Println("42 does not implement fmt.Stringer")
} else {
fmt.Println("42 implements fmt.Stringer")
return
}
// TODO(mpl): restore when fixed
// var tt interface{}
var tt DummyStringer
tt = TestStruct{}
ss, ok := tt.(fmt.Stringer)
if !ok {
fmt.Println("TestStuct does not implement fmt.Stringer")
return
}
fmt.Println(ss.String())
fmt.Println(tt.(fmt.Stringer).String())
if _, ok := tt.(fmt.Stringer); !ok {
fmt.Println("TestStuct does not implement fmt.Stringer")
return
} else {
fmt.Println("TestStuct implements fmt.Stringer")
}
}
// Output:
// 1ns
// 1ns
// true
// time.Nanosecond implements fmt.Stringer
// 42 does not implement fmt.Stringer
// 42 does not implement fmt.Stringer
// hello world
// hello world
// TestStuct implements fmt.Stringer
================================================
FILE: _test/assert2.go
================================================
package main
import (
"strings"
"sync"
)
// Define an interface of stringBuilder that is compatible with
// strings.Builder(go 1.10) and bytes.Buffer(< go 1.10).
type stringBuilder interface {
WriteRune(r rune) (n int, err error)
WriteString(s string) (int, error)
Reset()
Grow(n int)
String() string
}
var builderPool = sync.Pool{New: func() interface{} {
return newStringBuilder()
}}
func newStringBuilder() stringBuilder {
return &strings.Builder{}
}
func main() {
i := builderPool.Get()
sb := i.(stringBuilder)
_, _ = sb.WriteString("hello")
println(sb.String())
builderPool.Put(i)
}
// Output:
// hello
================================================
FILE: _test/assert3.go
================================================
package main
import "crypto/rsa"
func main() {
var pKey interface{} = &rsa.PublicKey{}
if _, ok := pKey.(*rsa.PublicKey); ok {
println("ok")
} else {
println("nok")
}
}
// Output:
// ok
================================================
FILE: _test/assert4.go
================================================
package main
var cc interface{} = 2
var dd = cc.(int)
func main() {
println(dd)
}
// Output:
// 2
================================================
FILE: _test/assign.go
================================================
package main
func main() {
a, b := 1, 2 // Multiple assign
println(a, b)
}
// Output:
// 1 2
================================================
FILE: _test/assign0.go
================================================
package main
import (
"fmt"
"net/http"
"time"
)
func main() {
http.DefaultClient.Timeout = time.Second * 10
fmt.Println(http.DefaultClient)
http.DefaultClient = &http.Client{}
fmt.Println(http.DefaultClient)
}
// Output:
// &{<nil> <nil> <nil> 10s}
// &{<nil> <nil> <nil> 0s}
================================================
FILE: _test/assign1.go
================================================
package main
import "fmt"
func main() {
var buf []byte
buf = nil
fmt.Println(buf)
}
// Output:
// []
================================================
FILE: _test/assign10.go
================================================
package main
func main() {
var a uint
a = 1 + 2
println(a)
}
// Output:
// 3
================================================
FILE: _test/assign11.go
================================================
package main
import "fmt"
func main() {
_, _, _ = fmt.Println("test")
}
// Error:
// 6:2: assignment mismatch: 3 variables but fmt.Println returns 2 values
================================================
FILE: _test/assign12.go
================================================
package main
import "fmt"
func main() {
a, b, c := fmt.Println("test")
println(a, b, c)
}
// Error:
// 6:2: assignment mismatch: 3 variables but fmt.Println returns 2 values
================================================
FILE: _test/assign13.go
================================================
package main
import "fmt"
func getStr() string {
return "test"
}
func main() {
m := make(map[string]string, 0)
m["a"] = fmt.Sprintf("%v", 0.1)
m["b"] = string(fmt.Sprintf("%v", 0.1))
m["c"] = getStr()
fmt.Println(m)
}
// Output:
// map[a:0.1 b:0.1 c:test]
================================================
FILE: _test/assign14.go
================================================
package main
var optionsG map[string]string = nil
var roundG = 30
func main() {
dummy := roundG
roundG = dummy + 1
println(roundG)
println(optionsG == nil)
}
// Output:
// 31
// true
================================================
FILE: _test/assign15.go
================================================
package main
func main() {
var c chan<- struct{} = make(chan struct{})
var d <-chan struct{} = c
_ = d
}
// Error:
// _test/assign15.go:5:26: cannot use type chan<- struct {} as type <-chan struct {} in assignment
================================================
FILE: _test/assign16.go
================================================
package main
type H struct {
bits uint
}
func main() {
h := &H{8}
var x uint = (1 << h.bits) >> 6
println(x)
}
// Output:
// 4
================================================
FILE: _test/assign17.go
================================================
package main
func main() {
s := make([]map[string]string, 0)
m := make(map[string]string)
m["m1"] = "m1"
m["m2"] = "m2"
s = append(s, m)
tmpStr := "start"
println(tmpStr)
for _, v := range s {
tmpStr, ok := v["m1"]
println(tmpStr, ok)
}
println(tmpStr)
}
// Output:
// start
// m1 true
// start
================================================
FILE: _test/assign18.go
================================================
package main
func main() {
s := make([]map[string]string, 0)
m := make(map[string]string)
m["m1"] = "m1"
m["m2"] = "m2"
s = append(s, m)
tmpStr := "start"
println(tmpStr)
for _, v := range s {
tmpStr, _ := v["m1"]
println(tmpStr)
}
println(tmpStr)
}
// Output:
// start
// m1
// start
================================================
FILE: _test/assign19.go
================================================
package main
func main() {
a, b, c := 1, 2
_, _, _ = a, b, c
}
// Error:
// _test/assign19.go:4:2: cannot assign 2 values to 3 variables
================================================
FILE: _test/assign2.go
================================================
package main
func main() {
r := uint32(2000000000)
r = hello(r)
println(r)
}
func hello(r uint32) uint32 { return r + 1 }
// Output:
// 2000000001
================================================
FILE: _test/assign3.go
================================================
package main
func main() {
a, b := 1, 2
println(a, b)
a, b = b, a
println(a, b)
}
// Output:
// 1 2
// 2 1
================================================
FILE: _test/assign4.go
================================================
package main
func main() {
a, b, c := 1, 2, 3
println(a, b, c)
a, b, c = c, a, b
println(a, b, c)
}
// Output:
// 1 2 3
// 3 1 2
================================================
FILE: _test/assign5.go
================================================
package main
import "fmt"
func main() {
t := []int{1, 2}
fmt.Println(t)
t[0], t[1] = t[1], t[0]
fmt.Println(t)
}
// Output:
// [1 2]
// [2 1]
================================================
FILE: _test/assign6.go
================================================
package main
import "fmt"
func main() {
t := map[string]int{"a": 1, "b": 2}
fmt.Println(t["a"], t["b"])
t["a"], t["b"] = t["b"], t["a"]
fmt.Println(t["a"], t["b"])
}
// Output:
// 1 2
// 2 1
================================================
FILE: _test/assign7.go
================================================
package main
import "fmt"
func main() {
a := 3
t := map[string]int{"a": 1, "b": 2}
s := []int{4, 5}
fmt.Println(a, t["b"], s)
a, t["b"], s[1] = t["b"], s[1], a
fmt.Println(a, t["b"], s)
}
// Output:
// 3 2 [4 5]
// 2 5 [4 3]
================================================
FILE: _test/assign8.go
================================================
package main
func main() {
_ = 1
println(1)
}
// Output:
// 1
================================================
FILE: _test/assign9.go
================================================
package main
type foo func(b int)
func boo(b int) { println("boo", b) }
func main() {
var f foo
f = boo
f(4)
}
// Output:
// boo 4
================================================
FILE: _test/b1/foo/foo.go
================================================
package foo
import bar "github.com/traefik/yaegi/_test/b2/foo"
var Desc = "in b1/foo"
var Desc2 = Desc + bar.Desc
================================================
FILE: _test/b2/foo/foo.go
================================================
package foo
var Desc = "in b2/foo"
================================================
FILE: _test/bad0.go
================================================
println("Hello")
// Error:
// 1:1: expected 'package', found println
================================================
FILE: _test/baz-bat/baz-bat.go
================================================
package baz
var Name = "baz-bat"
================================================
FILE: _test/bin.go
================================================
package main
import "fmt"
func main() {
f := fmt.Println
f("Hello")
}
// Output:
// Hello
================================================
FILE: _test/bin0.go
================================================
package main
import "strings"
func main() {
a := strings.SplitN("truc machin", " ", 2)
println(a[0])
}
// Output:
// truc
================================================
FILE: _test/bin1.go
================================================
package main
import (
"crypto/sha1"
"fmt"
)
func main() {
d := sha1.New()
d.Write([]byte("password"))
a := d.Sum(nil)
fmt.Println(a)
}
// Output:
// [91 170 97 228 201 185 63 63 6 130 37 11 108 248 51 27 126 230 143 216]
================================================
FILE: _test/bin2.go
================================================
package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(math.Abs(-5))
}
// Output:
// 5
================================================
FILE: _test/bin3.go
================================================
package main
import "fmt"
func main() {
str := "part1"
str += fmt.Sprintf("%s", "part2")
fmt.Println(str)
}
// Output:
// part1part2
================================================
FILE: _test/bin4.go
================================================
package main
import (
"fmt"
"strings"
)
func Bar(s string) bool {
a := strings.HasPrefix("fas", "f")
b := strings.HasPrefix("aaaaa", "a")
a_and_b := strings.HasPrefix("fas", "f") && strings.HasPrefix("aaaaa", "a")
fmt.Println(a, b, a && b, a_and_b)
return a && b
}
func main() {
println(Bar("kung"))
}
================================================
FILE: _test/bin5.go
================================================
package main
import (
"fmt"
"net"
)
func main() {
addr := net.TCPAddr{IP: net.IPv4(1, 1, 1, 1), Port: 80}
var s fmt.Stringer = &addr
fmt.Println(s.String())
}
// Output:
// 1.1.1.1:80
================================================
FILE: _test/binstruct_ptr_map0.go
================================================
package main
import (
"fmt"
"image"
)
func main() {
v := map[string]*image.Point{
"foo": {X: 3, Y: 2},
"bar": {X: 4, Y: 5},
}
fmt.Println(v["foo"], v["bar"])
}
// Output:
// (3,2) (4,5)
================================================
FILE: _test/binstruct_ptr_slice0.go
================================================
package main
import (
"fmt"
"image"
)
func main() {
v := []*image.Point{
{X: 3, Y: 2},
{X: 4, Y: 5},
}
fmt.Println(v)
}
// Output:
// [(3,2) (4,5)]
================================================
FILE: _test/binstruct_slice0.go
================================================
package main
import (
"fmt"
"image"
)
func main() {
v := []image.Point{
{X: 3, Y: 2},
}
fmt.Println(v)
}
// Output:
// [(3,2)]
================================================
FILE: _test/bltn.go
================================================
package main
func main() {
println("Hello")
}
// Output:
// Hello
================================================
FILE: _test/bltn0.go
================================================
package main
func main() {
f := println
f("Hello")
}
// Error:
// 4:7: use of builtin println not in function call
================================================
FILE: _test/bool.go
================================================
package main
import "fmt"
func main() {
fmt.Println(false, true)
}
// Output:
// false true
================================================
FILE: _test/bool0.go
================================================
package main
import "fmt"
func main() {
fmt.Println(true)
}
// Output:
// true
================================================
FILE: _test/bool1.go
================================================
package main
type T struct {
v bool
}
func main() {
a := T{}
if a.v {
println("ok")
} else {
println("nok")
}
}
// Output:
// nok
================================================
FILE: _test/bool2.go
================================================
package main
type T struct {
v bool
}
func main() {
a := &T{}
if a.v {
println("ok")
} else {
println("nok")
}
}
// Output:
// nok
================================================
FILE: _test/bool3.go
================================================
package main
func main() {
m := map[int]bool{0: false, 1: true}
if m[0] {
println(0)
} else {
println(1)
}
}
// Output:
// 1
================================================
FILE: _test/bool4.go
================================================
package main
func main() {
m := []bool{false, true}
if m[0] {
println(0)
} else {
println(1)
}
}
// Output:
// 1
================================================
FILE: _test/bool5.go
================================================
package main
func main() {
var b bool
m := &b
if *m {
println(0)
} else {
println(1)
}
}
// Output:
// 1
================================================
FILE: _test/break0.go
================================================
package main
func main() {
n := 2
m := 2
foo := true
OuterLoop:
println("Boo")
for i := 0; i < n; i++ {
println("I: ", i)
for j := 0; j < m; j++ {
switch foo {
case true:
println(foo)
break OuterLoop
case false:
println(foo)
}
}
}
}
// Error:
// 15:5: invalid break label OuterLoop
================================================
FILE: _test/break1.go
================================================
package main
func main() {
n := 2
m := 2
foo := true
OuterLoop:
for i := 0; i < n; i++ {
println("I: ", i)
for j := 0; j < m; j++ {
switch foo {
case true:
println(foo)
break OuterLoop
case false:
println(foo)
}
}
}
}
// Output:
// I: 0
// true
================================================
FILE: _test/break2.go
================================================
package main
func main() {
n := 2
m := 2
foo := true
OuterLoop:
for i := 0; i < n; i++ {
println("I: ", i)
for j := 0; j < m; j++ {
switch foo {
case true:
println(foo)
break OuterLoop
case false:
println(foo)
continue OuterLoop
}
}
}
}
// Output:
// I: 0
// true
================================================
FILE: _test/break3.go
================================================
package main
func main() {
n := 2
m := 2
foo := true
goto OuterLoop
println("Boo")
OuterLoop:
for i := 0; i < n; i++ {
println("I: ", i)
for j := 0; j < m; j++ {
switch foo {
case true:
println(foo)
break OuterLoop
case false:
println(foo)
goto OuterLoop
}
}
}
}
// Output:
// I: 0
// true
================================================
FILE: _test/c1/c1.go
================================================
package c1
import "github.com/traefik/yaegi/_test/c2"
var C1 = c2.C2 + "x"
================================================
FILE: _test/c2/c2.go
================================================
package c2
import "github.com/traefik/yaegi/_test/c1"
var C2 = c1.C1 + "Y"
================================================
FILE: _test/cap0.go
================================================
package main
func f(a []int) interface{} {
return cap(a)
}
func g(a []int) int {
return cap(a)
}
func main() {
a := []int{1, 2}
println(g(a))
println(f(a).(int))
}
// Output:
// 2
// 2
================================================
FILE: _test/chan0.go
================================================
package main
type Channel chan string
func send(c Channel) { c <- "ping" }
func main() {
channel := make(Channel)
go send(channel)
msg := <-channel
println(msg)
}
// Output:
// ping
================================================
FILE: _test/chan1.go
================================================
package main
func send(c chan<- string) { c <- "ping" }
func main() {
channel := make(chan string)
go send(channel)
msg := <-channel
println(msg)
}
// Output:
// ping
================================================
FILE: _test/chan10.go
================================================
package main
import "time"
func main() {
var tick <-chan time.Time = time.Tick(time.Millisecond)
_ = tick
println("success")
}
// Output:
// success
================================================
FILE: _test/chan2.go
================================================
package main
import "fmt"
func main() {
messages := make(chan string)
go func() { messages <- "ping" }()
msg := <-messages
fmt.Println(msg)
}
// Output:
// ping
================================================
FILE: _test/chan3.go
================================================
package main
func send(c chan<- int32) { c <- 123 }
func main() {
channel := make(chan int32)
go send(channel)
msg := <-channel
println(msg)
}
// Output:
// 123
================================================
FILE: _test/chan4.go
================================================
package main
func send(c chan<- bool) { c <- false }
func main() {
channel := make(chan bool)
go send(channel)
if <-channel {
println("ok")
} else {
println("nok")
}
}
// Output:
// nok
================================================
FILE: _test/chan5.go
================================================
package main
import "time"
func main() {
// For our example we'll select across two channels.
c1 := make(chan string)
c2 := make(chan string)
// Each channel will receive a value after some amount
// of time, to simulate e.g. blocking RPC operations
// executing in concurrent goroutines.
go func() {
//time.Sleep(1 * time.Second)
time.Sleep(1e9)
c1 <- "one"
}()
go func() {
time.Sleep(2e9)
c2 <- "two"
}()
msg1 := <-c1
println(msg1)
msg2 := <-c2
println(msg2)
}
================================================
FILE: _test/chan6.go
================================================
package main
func send(c chan<- int32) { c <- 123 }
func main() {
channel := make(chan int32)
go send(channel)
msg, ok := <-channel
println(msg, ok)
}
================================================
FILE: _test/chan7.go
================================================
package main
import "fmt"
func main() {
queue := make(chan string, 2)
queue <- "one"
queue <- "two"
close(queue)
for elem := range queue {
fmt.Println(elem)
}
}
// Output:
// one
// two
================================================
FILE: _test/chan8.go
================================================
package main
func main() {
messages := make(chan bool)
go func() { messages <- true }()
println(<-messages && true)
}
// Output:
// true
================================================
FILE: _test/chan9.go
================================================
package main
type Channel chan string
type T struct {
Channel
}
func send(c Channel) { c <- "ping" }
func main() {
t := &T{}
t.Channel = make(Channel)
go send(t.Channel)
msg := <-t.Channel
println(msg)
}
// Output:
// ping
================================================
FILE: _test/cli1.go
================================================
package main
import (
"fmt"
"io"
"log"
"net"
"net/http"
)
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
func server(ln net.Listener, ready chan bool) {
http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
var r1 *http.Request = r
fmt.Fprintln(w, "Welcome to my website!", r1.RequestURI)
})
go http.Serve(ln, nil)
ready <- true
}
func main() {
ln, err := net.Listen("tcp", "localhost:0")
if err != nil {
log.Fatal(err)
}
defer ln.Close()
ready := make(chan bool)
go server(ln, ready)
<-ready
client(fmt.Sprintf("http://%s/hello", ln.Addr().String()))
http.DefaultServeMux = &http.ServeMux{}
}
// Output:
// Welcome to my website! /hello
================================================
FILE: _test/cli2.go
================================================
package main
import (
"fmt"
"io"
"log"
"net"
"net/http"
)
type T struct {
ln net.Listener
}
func (t *T) Close() {
t.ln.Close()
}
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
func server(ln net.Listener, ready chan bool) {
http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
var r1 *http.Request = r
fmt.Fprintln(w, "Welcome to my website!", r1.RequestURI)
})
go http.Serve(ln, nil)
ready <- true
}
func main() {
ln, err := net.Listen("tcp", "localhost:0")
t := &T{ln}
if err != nil {
log.Fatal(err)
}
defer t.Close()
// defer ln.Close()
ready := make(chan bool)
go server(ln, ready)
<-ready
client(fmt.Sprintf("http://%s/hello", ln.Addr().String()))
http.DefaultServeMux = &http.ServeMux{}
}
// Output:
// Welcome to my website! /hello
================================================
FILE: _test/cli3.go
================================================
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/http/httptest"
)
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Welcome to my website!")
})
server := httptest.NewServer(mux)
defer server.Close()
client(server.URL)
}
// Output:
// Welcome to my website!
================================================
FILE: _test/cli4.go
================================================
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/http/httptest"
)
type mw1 struct {
next http.Handler
}
func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
m.next.ServeHTTP(rw, rq)
}
type mw0 struct{}
func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Welcome to my website!")
}
func main() {
m0 := &mw0{}
m1 := &mw1{m0}
mux := http.NewServeMux()
mux.HandleFunc("/", m1.ServeHTTP)
server := httptest.NewServer(mux)
defer server.Close()
client(server.URL)
}
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
// Output:
// Welcome to my website!
================================================
FILE: _test/cli5.go
================================================
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/http/httptest"
)
type mw1 struct {
next http.Handler
}
func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
m.next.ServeHTTP(rw, rq)
}
type mw0 struct{}
func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Welcome to my website!")
}
func main() {
m0 := &mw0{}
m1 := &mw1{next: m0}
mux := http.NewServeMux()
mux.HandleFunc("/", m1.ServeHTTP)
server := httptest.NewServer(mux)
defer server.Close()
client(server.URL)
}
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
// Output:
// Welcome to my website!
================================================
FILE: _test/cli6.go
================================================
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/http/httptest"
)
type T struct {
http.ResponseWriter
}
type mw1 struct {
next http.Handler
}
func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
t := &T{
ResponseWriter: rw,
}
x := t.Header()
fmt.Fprint(rw, "Welcome to my website!", x)
}
func main() {
m1 := &mw1{}
mux := http.NewServeMux()
mux.HandleFunc("/", m1.ServeHTTP)
server := httptest.NewServer(mux)
defer server.Close()
client(server.URL)
}
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
// Output:
// Welcome to my website!map[]
================================================
FILE: _test/cli7.go
================================================
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/http/httptest"
)
type T struct {
http.ResponseWriter
}
type mw1 struct {
}
var obj = map[string]interface{}{}
func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
t := &T{
ResponseWriter: rw,
}
x := t.Header()
i := obj["m1"].(*mw1)
fmt.Fprint(rw, "Welcome to my website!", x, i)
}
func main() {
m1 := &mw1{}
obj["m1"] = m1
mux := http.NewServeMux()
mux.HandleFunc("/", m1.ServeHTTP)
server := httptest.NewServer(mux)
defer server.Close()
client(server.URL)
}
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
log.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
// Output:
// Welcome to my website!map[] &{}
================================================
FILE: _test/cli8.go
================================================
package main
import (
"net/http"
"net/http/httptest"
)
type T struct {
name string
next http.Handler
}
func (t *T) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
println("in T.ServeHTTP")
if t.next != nil {
t.next.ServeHTTP(rw, req)
}
}
func New(name string, next http.Handler) (http.Handler, error) { return &T{name, next}, nil }
func main() {
next := func(rw http.ResponseWriter, req *http.Request) {
println("in next")
}
t, err := New("test", http.HandlerFunc(next))
if err != nil {
panic(err)
}
recorder := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/", nil)
t.ServeHTTP(recorder, req)
println(recorder.Result().Status)
}
// Output:
// in T.ServeHTTP
// in next
// 200 OK
================================================
FILE: _test/closure0.go
================================================
package main
type adder func(int, int) int
func genAdd(k int) adder {
return func(i, j int) int {
return i + j + k
}
}
func main() {
f := genAdd(5)
println(f(3, 4))
}
// Output:
// 12
================================================
FILE: _test/closure1.go
================================================
package main
type adder func(int, int) int
func genAdd(k int) adder {
return func(i, j int) int {
return i + j + k
}
}
func main() {
f := genAdd(5)
g := genAdd(8)
println(f(3, 4))
println(g(3, 4))
}
// Output:
// 12
// 15
================================================
FILE: _test/closure10.go
================================================
package main
func main() {
foos := []func(){}
for i := 0; i < 3; i++ {
a, b := i, i
foos = append(foos, func() { println(i, a, b) })
}
foos[0]()
foos[1]()
foos[2]()
}
// Output:
// 0 0 0
// 1 1 1
// 2 2 2
================================================
FILE: _test/closure11.go
================================================
package main
type T struct {
F func()
}
func main() {
foos := []T{}
for i := 0; i < 3; i++ {
a := i
foos = append(foos, T{func() { println(i, a) }})
}
foos[0].F()
foos[1].F()
foos[2].F()
}
// Output:
// 0 0
// 1 1
// 2 2
================================================
FILE: _test/closure12.go
================================================
package main
import "fmt"
type T struct {
F func()
}
func main() {
foos := []T{}
for i := 0; i < 3; i++ {
a := i
n := fmt.Sprintf("i=%d", i)
foos = append(foos, T{func() { println(i, a, n) }})
}
foos[0].F()
foos[1].F()
foos[2].F()
}
// Output:
// 0 0 i=0
// 1 1 i=1
// 2 2 i=2
================================================
FILE: _test/closure13.go
================================================
package main
import (
"fmt"
"strconv"
)
type monkey struct {
test func() int
}
func main() {
input := []string{"1", "2", "3"}
var monkeys []*monkey
for _, v := range input {
kong := monkey{}
divisor, err := strconv.Atoi(v)
if err != nil {
panic(err)
}
fmt.Print(divisor, " ")
kong.test = func() int {
return divisor
}
monkeys = append(monkeys, &kong)
}
for _, mk := range monkeys {
fmt.Print(mk.test(), " ")
}
}
// Output:
// 1 2 3 1 2 3
================================================
FILE: _test/closure14.go
================================================
package main
import "fmt"
type monkey struct {
test func() int
}
func getk(k int) (int, error) { return k, nil }
func main() {
input := []string{"1", "2", "3"}
var monkeys []*monkey
for k := range input {
kong := monkey{}
divisor, _ := getk(k)
fmt.Print(divisor, " ")
kong.test = func() int {
return divisor
}
monkeys = append(monkeys, &kong)
}
for _, mk := range monkeys {
fmt.Print(mk.test(), " ")
}
}
// Output:
// 0 1 2 0 1 2
================================================
FILE: _test/closure15.go
================================================
package main
func main() {
foos := []func(){}
for i := range 3 {
a := i
foos = append(foos, func() { println(i, a) })
}
foos[0]()
foos[1]()
foos[2]()
}
// Output:
// 0 0
// 1 1
// 2 2
================================================
FILE: _test/closure16.go
================================================
package main
func main() {
foos := []func(){}
for i := range 3 {
a, b := i, i
foos = append(foos, func() { println(i, a, b) })
}
foos[0]()
foos[1]()
foos[2]()
}
// Output:
// 0 0 0
// 1 1 1
// 2 2 2
================================================
FILE: _test/closure17.go
================================================
package main
type T struct {
F func()
}
func main() {
foos := []T{}
for i := range 3 {
a := i
foos = append(foos, T{func() { println(i, a) }})
}
foos[0].F()
foos[1].F()
foos[2].F()
}
// Output:
// 0 0
// 1 1
// 2 2
================================================
FILE: _test/closure18.go
================================================
package main
import "fmt"
type T struct {
F func()
}
func main() {
foos := []T{}
for i := range 3 {
a := i
n := fmt.Sprintf("i=%d", i)
foos = append(foos, T{func() { println(i, a, n) }})
}
foos[0].F()
foos[1].F()
foos[2].F()
}
// Output:
// 0 0 i=0
// 1 1 i=1
// 2 2 i=2
================================================
FILE: _test/closure19.go
================================================
package main
func main() {
foos := []func(){}
for i := 0; i < 3; i++ {
i := i
foos = append(foos, func() { println(i) })
}
foos[0]()
foos[1]()
foos[2]()
}
// Output:
// 0
// 1
// 2
================================================
FILE: _test/closure2.go
================================================
package main
func adder() func(int) int {
sum := 0
return func(x int) int {
sum = sum + x
return sum
}
}
func main() {
pos, neg := adder(), adder()
for i := 0; i < 10; i++ {
println(pos(i), neg(-2*i))
}
}
// Output:
// 0 0
// 1 -2
// 3 -6
// 6 -12
// 10 -20
// 15 -30
// 21 -42
// 28 -56
// 36 -72
// 45 -90
================================================
FILE: _test/closure20.go
================================================
package main
func main() {
foos := []func(){}
for i := range 3 {
i := i
foos = append(foos, func() { println(i) })
}
foos[0]()
foos[1]()
foos[2]()
}
// Output:
// 0
// 1
// 2
================================================
FILE: _test/closure3.go
================================================
package main
type T1 struct {
Name string
}
func (t *T1) genAdd(k int) func(int) int {
return func(i int) int {
println(t.Name)
return i + k
}
}
var t = &T1{"test"}
func main() {
f := t.genAdd(4)
println(f(5))
}
// Output:
// test
// 9
================================================
FILE: _test/closure4.go
================================================
package main
type T1 struct {
Name string
}
func (t *T1) genAdd(k int) func(int) int {
return func(i int) int {
println(t.Name)
return i + k
}
}
var t = T1{"test"}
func main() {
f := t.genAdd(4)
println(f(5))
}
// Output:
// test
// 9
================================================
FILE: _test/closure5.go
================================================
package main
type T1 struct {
Name string
}
func (t T1) genAdd(k int) func(int) int {
return func(i int) int {
println(t.Name)
return i + k
}
}
var t = T1{"test"}
func main() {
f := t.genAdd(4)
println(f(5))
}
// Output:
// test
// 9
================================================
FILE: _test/closure6.go
================================================
package main
type T1 struct {
Name string
}
func (t *T1) genAdd(k int) func(int) int {
return func(i int) int {
println(t.Name)
return i + k
}
}
var t = &T1{"test"}
func main() {
f := t.genAdd(4)
println(f(5))
}
// Output:
// test
// 9
================================================
FILE: _test/closure7.go
================================================
package main
import (
"fmt"
)
type Config struct {
A string
}
var conf *Config = &Config{}
func SetConfig() func(*Config) {
return func(cf *Config) {
conf = cf
}
}
func main() {
conf := &Config{
A: "foo",
}
fmt.Println(conf.A)
}
// Output:
// foo
================================================
FILE: _test/closure8.go
================================================
package main
var f = func(a int) int { return 2 + a }
func main() {
println(f(3))
}
// Output:
// 5
================================================
FILE: _test/closure9.go
================================================
package main
func main() {
foos := []func(){}
for i := 0; i < 3; i++ {
a := i
foos = append(foos, func() { println(i, a) })
}
foos[0]()
foos[1]()
foos[2]()
}
// Output:
// 0 0
// 1 1
// 2 2
================================================
FILE: _test/comp0.go
================================================
package main
func main() {
println(2 < 2.4)
}
// Output:
// true
================================================
FILE: _test/comp1.go
================================================
package main
func main() {
var a interface{} = 1 < 2
println(a.(bool))
}
// Output:
// true
================================================
FILE: _test/comp2.go
================================================
package main
type delta int32
func main() {
a := delta(-1)
println(a != -1)
println(a == -1)
}
// Output:
// false
// true
================================================
FILE: _test/complex0.go
================================================
package main
import "fmt"
func main() {
a := complex(3, 2)
fmt.Println(a, real(a), imag(a))
}
// Output:
// (3+2i) 3 2
================================================
FILE: _test/complex1.go
================================================
package main
import "fmt"
func main() {
var c complex128
c = 1
fmt.Printf("%T %v\n", c, c)
}
// Output:
// complex128 (1+0i)
================================================
FILE: _test/complex2.go
================================================
package main
import "fmt"
func main() {
c := complex(1, 0)
c += 1
fmt.Printf("%T %v\n", c, c)
}
// Output:
// complex128 (2+0i)
================================================
FILE: _test/complex3.go
================================================
package main
import "fmt"
func main() {
var s int = 1 + complex(1, 0)
fmt.Printf("%T %v\n", s, s)
}
// Output:
// int 2
================================================
FILE: _test/complex4.go
================================================
package main
import "fmt"
func f(a, b float64) interface{} { return complex(a, b) }
func main() {
a := f(3, 2)
fmt.Println(a.(complex128))
}
// Output:
// (3+2i)
================================================
FILE: _test/composite0.go
================================================
package main
import "fmt"
var a = &[]*T{}
type T struct{ name string }
func main() {
fmt.Println(a)
}
// Output:
// &[]
================================================
FILE: _test/composite1.go
================================================
package main
import "fmt"
var a = &[]*T{{}}
type T struct{ name string }
func main() {
fmt.Println((*a)[0])
}
// Output:
// &{}
================================================
FILE: _test/composite10.go
================================================
package main
import "fmt"
func main() {
a := []map[int]int{make(map[int]int)}
for _, b := range a {
fmt.Println(b)
}
}
// Output:
// map[]
================================================
FILE: _test/composite11.go
================================================
package main
import (
"fmt"
"image/color"
)
func main() {
c := color.NRGBA64{1, 1, 1, 1}
fmt.Println(c)
}
// Output:
// {1 1 1 1}
================================================
FILE: _test/composite12.go
================================================
package main
type A struct {
C D
}
type D struct {
E string
}
func main() {
a := A{}
a.C = D{"bb"}
println(a.C.E)
}
// Output:
// bb
================================================
FILE: _test/composite13.go
================================================
package main
type A struct {
C D
}
type D struct {
E string
}
func main() {
a := A{}
a.C = D{E: "bb"}
println(a.C.E)
}
// Output:
// bb
================================================
FILE: _test/composite14.go
================================================
package main
import "fmt"
type T struct {
b []byte
}
func main() {
t := T{nil}
fmt.Println(t)
}
// Output:
// {[]}
================================================
FILE: _test/composite15.go
================================================
package main
import (
"fmt"
)
func interfaceAsInts() {
var a interface{}
b := 2
c := 3
a = []int{b, c}
d, ok := a.([]int)
if !ok {
println("nope")
return
}
for _, v := range d {
fmt.Println(v)
}
}
func interfaceAsInterfaces() {
var a, b, c interface{}
b = 2
c = 3
a = []interface{}{b, c}
d, ok := a.([]interface{})
if !ok {
println("nope")
return
}
fmt.Println(d)
for _, v := range d {
fmt.Println(v)
}
}
func main() {
interfaceAsInts()
interfaceAsInterfaces()
}
// Output:
// 2
// 3
// [2 3]
// 2
// 3
================================================
FILE: _test/composite16.go
================================================
package main
import (
"fmt"
"net/url"
)
func main() {
body := url.Values{
"Action": {"none"},
}
fmt.Println(body)
}
// Output:
// map[Action:[none]]
================================================
FILE: _test/composite17.go
================================================
package main
import (
"html/template"
)
var str = `{{ stringOr .Data "test" }}`
func main() {
_, err := template.New("test").
Funcs(template.FuncMap{
"stringOr": stringOr,
}).
Parse(str)
if err != nil {
println(err.Error())
return
}
println("success")
}
func stringOr(v, def string) string {
if v == "" {
return def
}
return v
}
// Output:
// success
================================================
FILE: _test/composite18.go
================================================
package main
import "fmt"
type fn func(string, string) bool
var funcs = []fn{
cmpLessFn,
cmpGreaterFn,
nil,
}
func cmpLessFn(a string, b string) bool {
return a < b
}
func cmpGreaterFn(a string, b string) bool {
return a > b
}
func main() {
for _, f := range funcs {
if f == nil {
continue
}
fmt.Println(f("a", "b"))
}
}
// Output:
// true
// false
================================================
FILE: _test/composite19.go
================================================
package main
import "fmt"
type fn func(string, string) bool
var funcs = map[string]fn{
"less": cmpLessFn,
"greater": cmpGreaterFn,
"none": nil,
}
func cmpLessFn(a string, b string) bool {
return a < b
}
func cmpGreaterFn(a string, b string) bool {
return a > b
}
func main() {
for _, n := range []string{"less", "greater", "none"} {
f := funcs[n]
if f == nil {
continue
}
fmt.Println(f("a", "b"))
}
}
// Output:
// true
// false
================================================
FILE: _test/composite2.go
================================================
package main
import "fmt"
var a = &[]*T{{"hello"}}
type T struct{ name string }
func main() {
fmt.Println((*a)[0])
}
// Output:
// &{hello}
================================================
FILE: _test/composite3.go
================================================
package main
func main() {
var err error
var ok bool
_, ok = err.(interface{ IsSet() bool })
println(ok)
}
// Output:
// false
================================================
FILE: _test/composite4.go
================================================
package main
func main() {
var err error
_, ok := err.(interface{ IsSet() bool })
println(ok)
}
// Output:
// false
================================================
FILE: _test/composite5.go
================================================
package main
import "fmt"
type T struct {
m uint16
}
var t = T{1<<2 | 1<<3}
func main() {
fmt.Println(t)
}
// Output:
// {12}
================================================
FILE: _test/composite6.go
================================================
package main
import (
"fmt"
"github.com/traefik/yaegi/_test/ct1"
)
type T struct {
m uint16
}
var t = T{1 << ct1.R}
func main() {
fmt.Println(t)
}
// Output:
// {2}
================================================
FILE: _test/composite7.go
================================================
package main
type T struct {
name string
}
var tab = []*T{{
name: "foo",
}, {
name: "bar",
}}
func main() {
println(len(tab))
println(tab[0].name)
}
// Output:
// 2
// foo
================================================
FILE: _test/composite8.go
================================================
package main
type T struct{ I int }
func main() {
t := []*T{}
s := []int{1, 2}
for _, e := range s {
x := &T{e}
t = append(t, x)
}
println(t[0].I, t[1].I)
}
// Output:
// 1 2
================================================
FILE: _test/composite8bis.go
================================================
package main
type T struct{ I int }
func main() {
t := []*T{}
s := []int{1, 2}
for _, e := range s {
x := &T{I: e}
t = append(t, x)
}
println(t[0].I, t[1].I)
}
// Output:
// 1 2
================================================
FILE: _test/composite9.go
================================================
package main
import "fmt"
func main() {
a := [][]int{make([]int,0)}
for _, b := range a {
fmt.Println(b)
}
}
// Output:
// []
================================================
FILE: _test/const0.go
================================================
package main
const (
a = iota
b
)
func main() {
println(a, b)
}
// Output:
// 0 1
================================================
FILE: _test/const1.go
================================================
package main
type T struct {
a int
b string
}
var t = T{1, "hello"}
func main() {
println(t.a, t.b)
}
// Output:
// 1 hello
================================================
FILE: _test/const10.go
================================================
package main
const (
a = 2
b = c + d
c = a + d
d = e + f
e = 3
f = 4
)
func main() {
println(b)
}
// Output:
// 16
================================================
FILE: _test/const11.go
================================================
package main
func main() {
const (
x = 2 * iota
dim
)
var t [dim * 2]int
println(t[0], len(t))
}
// Output:
// 0 4
================================================
FILE: _test/const12.go
================================================
package main
type Kind int
const (
None Kind = 0
Left Kind = 1 << iota
Right
Both Kind = Left | Right
)
func main() {
println(None, Left, Right, Both)
}
// Output:
// 0 2 4 6
================================================
FILE: _test/const13.go
================================================
package main
import (
"fmt"
)
func main() {
const tooBig = 1267650600228229401496703205376
const huge = 1 << 100
const large = huge >> 38
fmt.Println(int64(large))
}
// Output:
// 4611686018427387904
================================================
FILE: _test/const14.go
================================================
package main
import "compress/flate"
func f1(i int) { println("i:", i) }
func main() {
i := flate.BestSpeed
f1(i)
}
// Output:
// i: 1
================================================
FILE: _test/const15.go
================================================
package main
type T1 t1
type t1 int8
const (
P2 T1 = 2
P3 T1 = 3
)
func main() {
println(P3)
}
// Output:
// 3
================================================
FILE: _test/const16.go
================================================
package main
import (
"fmt"
)
func main() {
fmt.Println(7 / 3)
}
// Output:
// 2
================================================
FILE: _test/const17.go
================================================
package main
import "fmt"
var t [7/3]int
func main() {
t[0] = 3/2
t[1] = 5/2
fmt.Println(t)
}
// Output:
// [1 2]
================================================
FILE: _test/const18.go
================================================
package main
import "time"
func main() {
a := int64(time.Second)
println(a)
}
// Output:
// 1000000000
================================================
FILE: _test/const19.go
================================================
package main
import (
"fmt"
"time"
)
func get10Hours() time.Duration {
return 10 * time.Hour
}
func main() {
fmt.Println(get10Hours().String())
}
// Output:
// 10h0m0s
================================================
FILE: _test/const2.go
================================================
package main
func main() {
println(a)
}
const a = "hello"
// Output:
// hello
================================================
FILE: _test/const20.go
================================================
package main
import "fmt"
const maxLen = int64(int64(^uint64(0) >> 1))
func main() {
fmt.Println(maxLen)
}
// Output:
// 9223372036854775807
================================================
FILE: _test/const21.go
================================================
package main
const a = 64
var b uint = a * a / 2
func main() {
println(b)
}
// Output:
// 2048
================================================
FILE: _test/const22.go
================================================
package main
const (
numDec uint8 = (1 << iota) / 2
numHex
numOct
numFloat
)
func main() {
println(13 & (numHex | numOct))
}
// Output:
// 1
================================================
FILE: _test/const23.go
================================================
package main
const maxlen = len("hello")
var gfm = [maxlen]byte{}
func main() {
println(len(gfm))
}
// Output:
// 5
================================================
FILE: _test/const24.go
================================================
package main
var aa = [...]int{1, 2, 3}
const maxlen = cap(aa)
var gfm = [maxlen]byte{}
func main() {
println(len(gfm))
}
// Output:
// 3
================================================
FILE: _test/const25.go
================================================
package main
const (
FGBlack Attribute = iota + 30
)
type Attribute int
func main() {
println(FGBlack)
}
================================================
FILE: _test/const26.go
================================================
package main
import (
"fmt"
)
func init() {
fmt.Println(constString)
fmt.Println(const2)
fmt.Println(varString)
}
const constString string = "hello"
const (
const1 = iota + 10
const2
const3
)
var varString string = "test"
func main() {}
// Output:
// hello
// 11
// test
================================================
FILE: _test/const3.go
================================================
package main
const a, b, c int = 1, 2, 3
func main() { println(a, b, c) }
// Output:
// 1 2 3
================================================
FILE: _test/const4.go
================================================
package main
const (
a = 2
b = 3
c
)
func main() {
println(a, b, c)
}
// Output:
// 2 3 3
================================================
FILE: _test/const5.go
================================================
package main
import (
"fmt"
)
const (
a uint8 = 2 * iota
b
c
)
func main() {
fmt.Printf("%T\n", c)
fmt.Println(a, b, c)
}
// Output:
// uint8
// 0 2 4
================================================
FILE: _test/const6.go
================================================
package main
const (
maxNonStarters = 30
maxBufferSize = maxNonStarters + 2
)
type reorderBuffer struct {
rune [maxBufferSize]Properties
}
type Properties struct {
pos uint8
size uint8
}
func main() {
println(len(reorderBuffer{}.rune))
}
// Output:
// 32
================================================
FILE: _test/const7.go
================================================
package main
import "fmt"
const (
a = iota
b
c
d
)
type T [c]int
func main() {
fmt.Println(T{})
}
// Output:
// [0 0]
================================================
FILE: _test/const8.go
================================================
package main
const (
a = 2
b = c + d
c = 4
d = 5
)
func main() {
println(a, b, c, d)
}
// Output:
// 2 9 4 5
================================================
FILE: _test/const9.go
================================================
package main
const (
a = 2
b = c + d
c = a + d
d = e + f
e = b + 2
f = 4
)
func main() {
println(b)
}
// Error:
// 5:2: constant definition loop
================================================
FILE: _test/cont.go
================================================
package main
func main() {
for i := 0; i < 10; i++ {
if i < 5 {
continue
}
println(i)
}
}
// Output:
// 5
// 6
// 7
// 8
// 9
================================================
FILE: _test/cont0.go
================================================
package main
func main() {
i := 0
for {
if i > 10 {
break
}
i++
if i < 5 {
continue
}
println(i)
}
}
// Output:
// 5
// 6
// 7
// 8
// 9
// 10
// 11
================================================
FILE: _test/cont1.go
================================================
package main
func main() {
i := 0
for {
if i > 10 {
break
}
if i < 5 {
i++
continue
}
println(i)
i++
}
}
// Output:
// 5
// 6
// 7
// 8
// 9
// 10
================================================
FILE: _test/cont2.go
================================================
package main
func main() {
n := 2
m := 2
foo := true
OuterLoop:
for i := 0; i < n; i++ {
println("I: ", i)
for j := 0; j < m; j++ {
switch foo {
case true:
println(foo)
continue OuterLoop
case false:
println(foo)
}
}
}
}
// Output:
// I: 0
// true
// I: 1
// true
================================================
FILE: _test/cont3.go
================================================
package main
func main() {
n := 2
m := 2
foo := true
OuterLoop:
println("boo")
for i := 0; i < n; i++ {
println("I: ", i)
for j := 0; j < m; j++ {
switch foo {
case true:
println(foo)
continue OuterLoop
case false:
println(foo)
}
}
}
}
// Error:
// 15:5: invalid continue label OuterLoop
================================================
FILE: _test/context.go
================================================
package main
import "context"
func get(ctx context.Context, k string) string {
var r string
if v := ctx.Value(k); v != nil {
r = v.(string)
}
return r
}
func main() {
ctx := context.WithValue(context.Background(), "hello", "world")
println(get(ctx, "hello"))
}
// Output:
// world
================================================
FILE: _test/context2.go
================================================
package main
import "context"
func get(ctx context.Context, k string) string {
var r string
var ok bool
if v := ctx.Value(k); v != nil {
r, ok = v.(string)
println(ok)
}
return r
}
func main() {
ctx := context.WithValue(context.Background(), "hello", "world")
println(get(ctx, "hello"))
}
// Output:
// true
// world
================================================
FILE: _test/convert0.go
================================================
package main
type T struct {
v int
}
type comparator func(T, T) bool
func sort(items []T, comp comparator) {
println("in sort")
}
func compT(t0, t1 T) bool { return t0.v < t1.v }
func main() {
a := []T{}
sort(a, comparator(compT))
}
// Output:
// in sort
================================================
FILE: _test/convert1.go
================================================
package main
import "strconv"
type atoidef func(s string) (int, error)
func main() {
stdatoi := atoidef(strconv.Atoi)
n, err := stdatoi("7")
if err != nil {
panic(err)
}
println(n)
}
// Output:
// 7
================================================
FILE: _test/convert2.go
================================================
package main
import "bufio"
func fakeSplitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) {
return 7, nil, nil
}
func main() {
splitfunc := bufio.SplitFunc(fakeSplitFunc)
n, _, err := splitfunc(nil, true)
if err != nil {
panic(err)
}
println(n)
}
// Output:
// 7
================================================
FILE: _test/convert3.go
================================================
package main
import (
"fmt"
"net/http"
)
func main() {
next := func(rw http.ResponseWriter, req *http.Request) {
rw.Header().Set("Cache-Control", "max-age=20")
rw.WriteHeader(http.StatusOK)
}
f := http.HandlerFunc(next)
fmt.Printf("%T\n", f.ServeHTTP)
}
// Output:
// func(http.ResponseWriter, *http.Request)
================================================
FILE: _test/copy0.go
================================================
package main
import "fmt"
func main() {
a := []int{10, 20, 30}
b := [4]int{}
c := b[:]
copy(c, a)
fmt.Println(c)
}
// Output:
// [10 20 30 0]
================================================
FILE: _test/copy1.go
================================================
package main
import "fmt"
func main() {
a := []int{10, 20, 30}
b := &[4]int{}
c := b[:]
copy(c, a)
fmt.Println(c)
}
// Output:
// [10 20 30 0]
================================================
FILE: _test/copy2.go
================================================
package main
import "fmt"
func f(a, b []int) interface{} { return copy(a, b) }
func main() {
a := []int{10, 20, 30}
b := [4]int{}
c := b[:]
r := f(c, a)
fmt.Println(r.(int))
}
// Output:
// 3
================================================
FILE: _test/ct/ct1.go
================================================
package ct
func init() { println("hello from ct1") }
================================================
FILE: _test/ct/ct2.go
================================================
// +build !dummy
package ct
func init() { println("hello from ct2") }
================================================
FILE: _test/ct/ct3.go
================================================
// +build dummy
package ct
func init() { println("hello from ct3") }
================================================
FILE: _test/ct1/ct1.go
================================================
package ct1
type Class uint
const (
L Class = iota
R
AL
)
================================================
FILE: _test/d1/d1.go
================================================
package d1
type T struct {
Name string
}
func (t *T) F() { println(t.Name) }
func NewT(s string) *T { return &T{s} }
================================================
FILE: _test/d2/d2.go
================================================
package d2
import "github.com/traefik/yaegi/_test/d1"
var (
X = d1.NewT("test")
F = X.F
)
================================================
FILE: _test/d3.go
================================================
package main
import "github.com/traefik/yaegi/_test/d2"
func main() {
f := d2.F
f()
}
// Output:
// test
================================================
FILE: _test/defer0.go
================================================
package main
import "fmt"
func main() {
println("hello")
defer fmt.Println("bye")
defer fmt.Println("au revoir")
println("world")
}
// Output:
// hello
// world
// au revoir
// bye
================================================
FILE: _test/defer1.go
================================================
package main
import "fmt"
func main() {
println("hello")
defer func() {
fmt.Println("bye")
}()
println("world")
}
// Output:
// hello
// world
// bye
================================================
FILE: _test/defer2.go
================================================
package main
import "fmt"
func main() {
println("hello")
i := 12
defer func() {
fmt.Println("i:", i)
}()
i = 20
println("world")
}
// Output:
// hello
// world
// i: 20
================================================
FILE: _test/defer3.go
================================================
package main
import (
"net/http"
"net/http/httptest"
)
func main() {
println("hello")
mux := http.NewServeMux()
server := httptest.NewServer(mux)
defer server.Close()
}
// Output:
// hello
================================================
FILE: _test/defer4.go
================================================
package main
import "sync"
type T struct {
mu sync.RWMutex
name string
}
func (t *T) get() string {
t.mu.RLock()
defer t.mu.RUnlock()
return t.name
}
var d = T{name: "test"}
func main() {
println(d.get())
}
// Output:
// test
================================================
FILE: _test/defer5.go
================================================
package main
func f1() {
defer println("f1-begin")
f2()
defer println("f1-end")
}
func f2() {
defer println("f2-begin")
f3()
defer println("f2-end")
}
func f3() {
defer println("f3-begin")
println("hello")
defer println("f3-end")
}
func main() {
f1()
}
// Output:
// hello
// f3-end
// f3-begin
// f2-end
// f2-begin
// f1-end
// f1-begin
================================================
FILE: _test/defer6.go
================================================
package main
func f1() {
defer print("f1-begin ")
f2()
defer print("f1-end ")
}
func f2() {
defer print("f2-begin ")
f3()
defer print("f2-end ")
}
func f3() {
defer print("f3-begin ")
print("hello ")
defer print("f3-end ")
}
func main() {
f1()
println()
}
// Output:
// hello f3-end f3-begin f2-end f2-begin f1-end f1-begin
================================================
FILE: _test/defer7.go
================================================
package main
import "fmt"
func f1(in, out []string) {
defer copy(out, in)
}
func main() {
in := []string{"foo", "bar"}
out := make([]string, 2)
f1(in, out)
fmt.Println(out)
}
// Output:
// [foo bar]
================================================
FILE: _test/defer8.go
================================================
package main
import "fmt"
func f1(m map[string]string) {
defer delete(m, "foo")
defer delete(m, "test")
fmt.Println(m)
}
func main() {
m := map[string]string{
"foo": "bar",
"baz": "bat",
}
f1(m)
fmt.Println(m)
}
// Output:
// map[baz:bat foo:bar]
// map[baz:bat]
================================================
FILE: _test/defer9.go
================================================
package main
import "fmt"
func f1(ch chan string) {
defer close(ch)
ch <- "foo"
}
func main() {
ch := make(chan string, 1)
f1(ch)
for s := range ch {
fmt.Println(s)
}
}
// Output:
// foo
================================================
FILE: _test/delete0.go
================================================
package main
import "fmt"
func main() {
a := map[string]int{"hello": 1, "world": 3}
delete(a, "hello")
fmt.Println(a)
}
// Output:
// map[world:3]
================================================
FILE: _test/eval0.go
================================================
package main
import (
"log"
"os"
"github.com/traefik/yaegi/interp"
)
func main() {
log.SetFlags(log.Lshortfile)
i := interp.New(interp.Options{Stdout: os.Stdout})
if _, err := i.Eval(`func f() (int, int) { return 1, 2 }`); err != nil {
log.Fatal(err)
}
if _, err := i.Eval(`a, b := f()`); err != nil {
log.Fatal(err)
}
if _, err := i.Eval(`println(a, b)`); err != nil {
log.Fatal(err)
}
}
// Output:
// 1 2
================================================
FILE: _test/export0.go
================================================
package main
func Test() {
println("Hello from test")
}
// Output:
//
================================================
FILE: _test/export1.go
================================================
package sample
type Sample struct{ Name string }
func (s *Sample) Test() {
println("Hello from test", s.Name)
}
// Output:
//
================================================
FILE: _test/factor.go
================================================
package main
import (
"fmt"
"math/big"
)
func main() {
// 157 bit n = pq with p ~= 78 bits
n := big.NewInt(0)
n.SetString("273966616513101251352941655302036077733021013991", 10)
i := big.NewInt(0)
// Set i to be p - 10e6
i.SetString("496968652506233112158689", 10)
// Move temp big int out here so no possible GC thrashing
temp := big.NewInt(0)
// Avoid creating the new bigint each time
two := big.NewInt(2)
for {
// Check if the odd number is a divisor of n
temp.Mod(n, i)
if temp.Sign() == 0 {
fmt.Println(i)
break
}
i.Add(i, two)
}
}
================================================
FILE: _test/fib.go
================================================
package main
// Compute fibonacci numbers, no memoization
func fib(n int) int {
if n < 2 {
return n
}
return fib(n-2) + fib(n-1)
}
func main() {
println(fib(35))
//println(fib(10))
}
================================================
FILE: _test/fib0.go
================================================
package main
// Compute fibonacci numbers, no memoization
func fib(n int) int {
if n < 2 {
return n
}
return fib(n-2) + fib(n-1)
}
func main() {
println(fib(4))
}
// Output:
// 3
================================================
FILE: _test/file_access.go
================================================
package main
import (
"fmt"
"os"
)
func main() {
file, err := os.CreateTemp("", "yeagibench")
if err != nil {
panic(err)
}
n, err := file.Write([]byte("hello world"))
if err != nil {
panic(err)
}
fmt.Println("n:", n)
err = file.Close()
if err != nil {
panic(err)
}
b, err := os.ReadFile(file.Name())
if err != nil {
panic(err)
}
fmt.Println("b:", string(b))
err = os.Remove(file.Name())
if err != nil {
panic(err)
}
}
// Output:
// n: 11
// b: hello world
================================================
FILE: _test/flag0.go
================================================
package main
import (
"flag"
"fmt"
)
func main() {
flag.Parse()
fmt.Println("Narg:", flag.NArg())
}
// Output:
// Narg: 0
================================================
FILE: _test/foo/bar.go
================================================
package foo
import "github.com/traefik/yaegi/_test/foo/boo"
var Bar = "BARR"
var Boo = boo.Boo
func init() { println("init foo") }
================================================
FILE: _test/foo/bir.go
================================================
package foo
import "github.com/traefik/yaegi/_test/foo/boo"
var Bir = boo.Boo + "22"
================================================
FILE: _test/foo/boo/boo.go
================================================
package boo
var Boo = "Boo"
func init() { println("init boo") }
================================================
FILE: _test/foo-bar/foo-bar.go
================================================
package bar
var Name = "foo-bar"
================================================
FILE: _test/for0.go
================================================
package main
func main() {
i := 0
//for ;i >= 0; i++ {
for {
if i > 5 {
break
}
println(i)
i++
}
}
// Output:
// 0
// 1
// 2
// 3
// 4
// 5
================================================
FILE: _test/for1.go
================================================
package main
func main() {
i := 0
for i < 10 {
if i > 4 {
break
}
println(i)
i++
}
}
// Output:
// 0
// 1
// 2
// 3
// 4
================================================
FILE: _test/for10.go
================================================
package main
func main() {
for a := 0; false; {
println("nok", a)
a++
break
}
println("bye")
}
// Output:
// bye
================================================
FILE: _test/for11.go
================================================
package main
func main() {
a := 0
for ; true; a++ {
println("nok", a)
break
}
println("bye", a)
}
// Output:
// nok 0
// bye 0
================================================
FILE: _test/for12.go
================================================
package main
func main() {
for a := 0; false; a++ {
println("nok", a)
break
}
println("bye")
}
// Output:
// bye
================================================
FILE: _test/for13.go
================================================
package main
func main() {
a := 0
for ; false; a++ {
println("nok", a)
break
}
println("bye", a)
}
// Output:
// bye 0
================================================
FILE: _test/for14.go
================================================
package main
func main() {
for a := 0; true; a++ {
println(a)
if a > 0 {
break
}
}
println("bye")
}
// Output:
// 0
// 1
// bye
================================================
FILE: _test/for15.go
================================================
package main
func f() int { println("in f"); return 1 }
func main() {
for i := f(); ; {
println("in loop")
if i > 0 {
break
}
}
}
// Output:
// in f
// in loop
================================================
FILE: _test/for16.go
================================================
package main
func main() {
max := 1
for ; ; max-- {
if max == 0 {
break
}
println("in for")
}
println("bye")
}
// Output:
// in for
// bye
================================================
FILE: _test/for17.go
================================================
package main
func main() {
mx := 3
for i := range mx {
println(i)
}
}
// Output:
// 0
// 1
// 2
================================================
FILE: _test/for18.go
================================================
package main
func main() {
for i := range 3 {
println(i)
}
}
// Output:
// 0
// 1
// 2
================================================
FILE: _test/for19.go
================================================
package main
func main() {
for range 3 {
println("i")
}
}
// Output:
// i
// i
// i
================================================
FILE: _test/for2.go
================================================
package main
func main() {
for i := 2; ; i++ {
println(i)
if i > 3 {
break
}
}
}
// Output:
// 2
// 3
// 4
================================================
FILE: _test/for3.go
================================================
package main
import (
"fmt"
"sort"
)
func main() {
m := map[string][]string{
"hello": []string{"foo", "bar"},
"world": []string{"truc", "machin"},
}
var content []string
for key, values := range m {
for _, value := range values {
content = append(content, key+value)
}
}
sort.Strings(content)
fmt.Println(content)
}
// Output:
// [hellobar hellofoo worldmachin worldtruc]
================================================
FILE: _test/for4.go
================================================
package main
func main() {
for i := 1; i <= 2; i++ {
var x, y int
println(x, y)
x, y = i, 2*i
println(x, y)
}
}
// Output:
// 0 0
// 1 2
// 0 0
// 2 4
================================================
FILE: _test/for5.go
================================================
package main
func main() {
var a bool
for a {
println("nok")
break
}
println("bye")
}
// Output:
// bye
================================================
FILE: _test/for6.go
================================================
package main
import "fmt"
func main() {
s := "三"
for i := 0; i < len(s); i++ {
fmt.Printf("byte %d: %d\n", i, s[i])
}
for i, r := range s {
fmt.Printf("rune %d: %d\n", i, r)
}
}
// Output:
// byte 0: 228
// byte 1: 184
// byte 2: 137
// rune 0: 19977
================================================
FILE: _test/for7.go
================================================
package main
func main() {
for i := 0; i; {
}
}
// Error:
// 4:14: non-bool used as for condition
================================================
FILE: _test/for8.go
================================================
package main
func main() {
for i := 0; i < 4; i++ {
for {
break
}
if i == 1 {
continue
}
println(i)
}
}
// Output:
// 0
// 2
// 3
================================================
FILE: _test/for9.go
================================================
package main
func main() {
for false {
println("nok")
break
}
println("bye")
}
// Output:
// bye
================================================
FILE: _test/fun.go
================================================
package main
func f(i int) int { return i + 15 }
func main() {
println(f(4))
}
// Output:
// 19
================================================
FILE: _test/fun10.go
================================================
package main
import "fmt"
func f() func() {
return nil
}
func main() {
g := f()
fmt.Printf("%T %v\n", g, g)
if g == nil {
fmt.Println("nil func")
}
}
// Output:
// func() <nil>
// nil func
================================================
FILE: _test/fun11.go
================================================
package main
var f F
type F func(int)
func main() {
println("ok")
}
// Output:
// ok
================================================
FILE: _test/fun12.go
================================================
package main
func use(interface{}) {}
func main() {
z := map[string]interface{}{"a": 5}
use(z)
println("bye")
}
// Output:
// bye
================================================
FILE: _test/fun13.go
================================================
package main
import "fmt"
type T struct{}
func newT() (T, error) { return T{}, nil }
func main() {
var (
i interface{}
err error
)
i, err = newT()
fmt.Println(i, err)
}
// Output:
// {} <nil>
================================================
FILE: _test/fun14.go
================================================
package main
func f() (bool, int) { return true, 2 }
func g() (bool, int) { return f() }
func main() {
b, i := g()
println(b, i)
}
// Output:
// true 2
================================================
FILE: _test/fun15.go
================================================
package main
func f1(a int) interface{} { return a + 1 }
func f2(a int64) interface{} { return a + 1 }
func main() {
c := f1(3)
println(c.(int))
b := f2(3)
println(b.(int64))
}
// Output:
// 4
// 4
================================================
FILE: _test/fun16.go
================================================
package main
func f1(a int) int { return a + 1 }
func f2(a int) interface{} {
// TODO: re-enable the optimized case below, once we've figured out why it
// interferes with the empty interface model.
// return f1(a)
var foo interface{} = f1(a)
return foo
}
func main() {
c := f2(3)
println(c.(int))
}
// Output:
// 4
================================================
FILE: _test/fun17.go
================================================
package main
func f1(a int) interface{} { return a + 1 }
func f2(a int) interface{} { return f1(a) }
func main() {
c := f2(3)
println(c.(int))
}
// Output:
// 4
================================================
FILE: _test/fun18.go
================================================
package main
var m = map[string]int{"foo": 1, "bar": 2}
func f(s string) interface{} { return m[s] }
func main() {
println(f("foo").(int))
}
// Output:
// 1
================================================
FILE: _test/fun19.go
================================================
package main
import (
"fmt"
)
func foo() ([]string, error) {
return nil, fmt.Errorf("bar")
}
func main() {
a, b := foo()
fmt.Println(a, b)
}
// Output:
// [] bar
================================================
FILE: _test/fun2.go
================================================
package main
type Coord struct{ x, y int }
func f(c Coord) int { return c.x + c.y }
func main() {
c := Coord{3, 4}
println(f(c))
}
// Output:
// 7
================================================
FILE: _test/fun20.go
================================================
package main
import "fmt"
var myerr error = fmt.Errorf("bar")
func ferr() error { return myerr }
func foo() ([]string, error) {
return nil, ferr()
}
func main() {
a, b := foo()
fmt.Println(a, b)
}
// Output:
// [] bar
================================================
FILE: _test/fun21.go
================================================
package main
func Bar() string {
return
}
func main() {
println(Bar())
}
// Error:
// 4:2: not enough arguments to return
================================================
FILE: _test/fun22.go
================================================
package main
import "time"
func main() {
time.Date()
}
// Error:
// 6:2: not enough arguments in call to time.Date
================================================
FILE: _test/fun23.go
================================================
package main
func f(x int) { return x }
func main() {
print("hello")
}
// Error:
// 3:17: too many arguments to return
================================================
FILE: _test/fun24.go
================================================
package main
func f(x int) (int, int) { return x, "foo" }
func main() {
print("hello")
}
// Error:
// cannot use "foo" (type stringT) as type intT in return argument
================================================
FILE: _test/fun25.go
================================================
package main
func f(x string) (a int, b int) { return x, 5 }
func main() {
print("hello")
}
// Error:
// cannot use x (type stringT) as type intT in return argument
================================================
FILE: _test/fun26.go
================================================
package main
type F func() (int, error)
func f1() (int, error) { return 3, nil }
func f2(a string, f F) {
c, _ := f()
println(a, c)
}
func main() {
f2("hello", F(f1))
}
// Output:
// hello 3
================================================
FILE: _test/fun27.go
================================================
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
print("test")
}()
wg.Wait()
}
func print(state string) {
fmt.Println(state)
}
// Output:
// test
================================================
FILE: _test/fun28.go
================================================
package main
import (
"runtime"
)
type T struct {
name string
}
func finalize(t *T) { println("finalize") }
func newT() *T {
t := new(T)
runtime.SetFinalizer(t, finalize)
return t
}
func main() {
t := newT()
println(t != nil)
}
// Output:
// true
================================================
FILE: _test/fun3.go
================================================
package main
type Coord struct{ x, y int }
func f(i, j int, c Coord) int { return i*c.x + j*c.y }
func main() {
c := Coord{3, 4}
println(f(2, 3, c))
}
// Output:
// 18
================================================
FILE: _test/fun4.go
================================================
package main
func f() {}
func main() {
f()
println("ok")
}
// Output:
// ok
================================================
FILE: _test/fun5.go
================================================
package main
func f(i int64) {
println(i)
}
func main() {
f(34)
}
// Output:
// 34
================================================
FILE: _test/fun6.go
================================================
package main
import (
"fmt"
"sync"
)
func NewPool() Pool { return Pool{} }
type Pool struct {
p *sync.Pool
}
var _pool = NewPool()
func main() {
fmt.Println(_pool)
}
// Output:
// {<nil>}
================================================
FILE: _test/fun7.go
================================================
package main
import (
goflag "flag"
"fmt"
)
func Foo(goflag *goflag.Flag) {
fmt.Println(goflag)
}
func main() {
g := &goflag.Flag{}
Foo(g)
}
// Output:
// &{ <nil> }
================================================
FILE: _test/fun8.go
================================================
package main
func main() { println(f == nil) }
var f func()
// Output:
// true
================================================
FILE: _test/fun9.go
================================================
package main
type T uint
func main() {
type myint int
var i = myint(1)
println(i)
}
// Output:
// 1
================================================
FILE: _test/gen1.go
================================================
package main
import "fmt"
// SumInts adds together the values of m.
func SumInts(m map[string]int64) int64 {
var s int64
for _, v := range m {
s += v
}
return s
}
// SumFloats adds together the values of m.
func SumFloats(m map[string]float64) float64 {
var s float64
for _, v := range m {
s += v
}
return s
}
func main() {
// Initialize a map for the integer values
ints := map[string]int64{
"first": 34,
"second": 12,
}
// Initialize a map for the float values
floats := map[string]float64{
"first": 35.98,
"second": 26.99,
}
fmt.Printf("Non-Generic Sums: %v and %v\n",
SumInts(ints),
SumFloats(floats))
}
================================================
FILE: _test/gen10.go
================================================
package main
func genFunc() (f func()) {
return f
}
func main() {
println(genFunc() == nil)
}
// Output:
// true
================================================
FILE: _test/gen11.go
================================================
package main
import (
"encoding/json"
"fmt"
"net/netip"
)
type Slice[T any] struct {
x []T
}
type IPPrefixSlice struct {
x Slice[netip.Prefix]
}
func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v.x) }
// MarshalJSON implements json.Marshaler.
func (v IPPrefixSlice) MarshalJSON() ([]byte, error) {
return v.x.MarshalJSON()
}
func main() {
t := IPPrefixSlice{}
fmt.Println(t)
b, e := t.MarshalJSON()
fmt.Println(string(b), e)
}
// Output:
// {{[]}}
// null <nil>
================================================
FILE: _test/gen12.go
================================================
package main
import (
"fmt"
)
func MapOf[K comparable, V any](m map[K]V) Map[K, V] {
return Map[K, V]{m}
}
type Map[K comparable, V any] struct {
ж map[K]V
}
func (v MapView) Int() Map[string, int] { return MapOf(v.ж.Int) }
type VMap struct {
Int map[string]int
}
type MapView struct {
ж *VMap
}
func main() {
mv := MapView{&VMap{}}
fmt.Println(mv.ж)
}
// Output:
// &{map[]}
================================================
FILE: _test/gen13.go
================================================
package main
type Map[K comparable, V any] struct {
ж map[K]V
}
func (m Map[K, V]) Has(k K) bool {
_, ok := m.ж[k]
return ok
}
func main() {
m := Map[string, float64]{}
println(m.Has("test"))
}
// Output:
// false
================================================
FILE: _test/gen2.go
================================================
package main
import "fmt"
// SumIntsOrFloats sums the values of map m. It supports both int64 and float64
// as types for map values.
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
var s V
for _, v := range m {
s += v
}
return s
}
func main() {
// Initialize a map for the integer values
ints := map[string]int64{
"first": 34,
"second": 12,
}
// Initialize a map for the float values
floats := map[string]float64{
"first": 35.98,
"second": 26.99,
}
fmt.Printf("Generic Sums: %v and %v\n",
SumIntsOrFloats[string, int64](ints),
SumIntsOrFloats[string, float64](floats))
}
// Output:
// Generic Sums: 46 and 62.97
================================================
FILE: _test/gen3.go
================================================
package main
type Number interface {
int | int64 | ~float64
}
func Sum[T Number](numbers []T) T {
var total T
for _, x := range numbers {
total += x
}
return total
}
func main() {
xs := []int{3, 5, 10}
total := Sum(xs)
println(total)
}
// Output:
// 18
================================================
FILE: _test/gen4.go
================================================
package main
import "fmt"
type List[T any] struct {
head, tail *element[T]
}
// A recursive generic type.
type element[T any] struct {
next *element[T]
val T
}
func (lst *List[T]) Push(v T) {
if lst.tail == nil {
lst.head = &element[T]{val: v}
lst.tail = lst.head
} else {
lst.tail.next = &element[T]{val: v}
lst.tail = lst.tail.next
}
}
func (lst *List[T]) GetAll() []T {
var elems []T
for e := lst.head; e != nil; e = e.next {
elems = append(elems, e.val)
}
return elems
}
func main() {
lst := List[int]{}
lst.Push(10)
lst.Push(13)
lst.Push(23)
fmt.Println("list:", lst.GetAll())
}
// Output:
// list: [10 13 23]
================================================
FILE: _test/gen5.go
================================================
package main
import "fmt"
type Set[Elem comparable] struct {
m map[Elem]struct{}
}
func Make[Elem comparable]() Set[Elem] {
return Set[Elem]{m: make(map[Elem]struct{})}
}
func (s Set[Elem]) Add(v Elem) {
s.m[v] = struct{}{}
}
func main() {
s := Make[int]()
s.Add(1)
fmt.Println(s)
}
// Output:
// {map[1:{}]}
================================================
FILE: _test/gen6.go
================================================
package main
func MapKeys[K comparable, V any](m map[K]V) []K {
r := make([]K, 0, len(m))
for k := range m {
r = append(r, k)
}
return r
}
func main() {
var m = map[int]string{1: "2", 2: "4", 4: "8"}
// Test type inference
println(len(MapKeys(m)))
}
// Output:
// 3
================================================
FILE: _test/gen7.go
================================================
package main
func MapKeys[K comparable, V any](m map[K]V) []K {
r := make([]K, 0, len(m))
for k := range m {
r = append(r, k)
}
return r
}
func main() {
var m = map[int]string{1: "2", 2: "4", 4: "8"}
// Test type inference
println(len(MapKeys))
}
// Error:
// invalid argument for len
================================================
FILE: _test/gen8.go
================================================
package main
type Float interface {
~float32 | ~float64
}
func add[T Float](a, b T) float64 { return float64(a) + float64(b) }
func main() {
var x, y int = 1, 2
println(add(x, y))
}
// Error:
// int does not implement main.Float
================================================
FILE: _test/gen9.go
================================================
package main
type Float interface {
~float32 | ~float64
}
func add[T Float](a, b T) float64 { return float64(a) + float64(b) }
func main() {
println(add(1, 2))
}
// Error:
// untyped int does not implement main.Float
================================================
FILE: _test/goto0.go
================================================
package main
func main() {
println("foo")
goto L1
println("Hello")
L1:
println("bar")
println("bye")
}
// Output:
// foo
// bar
// bye
================================================
FILE: _test/goto1.go
================================================
package main
func main() {
if true {
goto here
}
here:
println("ok")
}
// Output:
// ok
================================================
FILE: _test/heap.go
================================================
// This example demonstrates an integer heap built using the heap interface.
package main
import (
"container/heap"
"fmt"
)
// An IntHeap is a min-heap of ints.
type IntHeap []int
func (h IntHeap) Len() int { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *IntHeap) Push(x interface{}) {
// Push and Pop use pointer receivers because they modify the slice's length,
// not just its contents.
*h = append(*h, x.(int))
}
func (h *IntHeap) Pop() interface{} {
old := *h
n := len(old)
x := old[n-1]
*h = old[0 : n-1]
return x
}
// This example inserts several ints into an IntHeap, checks the minimum,
// and removes them in order of priority.
func main() {
h := &IntHeap{2, 1, 5}
heap.Init(h)
heap.Push(h, 3)
fmt.Printf("minimum: %d\n", (*h)[0])
fmt.Println("h:", h)
for h.Len() > 0 {
fmt.Printf("%d ", heap.Pop(h))
}
}
// Output:
// minimum: 1
// h: &[1 2 5 3]
// 1 2 3 5
================================================
FILE: _test/if.go
================================================
package main
func main() {
if a := f(); a > 0 {
println(a)
}
}
func f() int { return 1 }
// Output:
// 1
================================================
FILE: _test/if0.go
================================================
package main
func main() {
var a bool
if a {
println("ok")
} else {
println("nok")
}
}
// Output:
// nok
================================================
FILE: _test/if1.go
================================================
package main
func main() {
i := 1
if i > 0 {
}
println("bye")
}
// Output:
// bye
================================================
FILE: _test/if2.go
================================================
package main
import "fmt"
func main() {
var i int
if i % 1000000 {
fmt.Println("oops")
}
}
// Error:
// 7:5: non-bool used as if condition
================================================
FILE: _test/if3.go
================================================
package main
func main() {
a := 0
if false {
println("false")
a = 1
} else {
println("true")
a = -1
}
println(a)
}
// Output:
// true
// -1
================================================
FILE: _test/if4.go
================================================
package main
const bad = false
func main() {
a := 0
if bad {
println("false")
a = 1
} else {
println("true")
a = -1
}
println(a)
}
// Output:
// true
// -1
================================================
FILE: _test/if5.go
================================================
package main
func main() {
if true {
println("ok")
}
println("bye")
}
// Output:
// ok
// bye
================================================
FILE: _test/if6.go
================================================
package main
func main() {
if false {
println("nok")
}
println("bye")
}
// Output:
// bye
================================================
FILE: _test/if7.go
================================================
package main
func main() {
a := 0
b := false
if (b) {
a = 1
} else {
a = -1
}
println(a)
}
// Output:
// -1
================================================
FILE: _test/imag0.go
================================================
package main
import "fmt"
func f(c complex128) interface{} { return imag(c) }
func main() {
c := complex(3, 2)
a := f(c)
fmt.Println(a.(float64))
}
// Output:
// 2
================================================
FILE: _test/import0.go
================================================
package main
import "fmt"
func main() {
fmt.Println("Hello", 42)
}
// Output:
// Hello 42
================================================
FILE: _test/import1.go
================================================
package main
import f "fmt"
func main() {
f.Println("Hello", 42)
}
// Output:
// Hello 42
================================================
FILE: _test/import2.go
================================================
package main
import . "fmt"
func main() {
Println("Hello", 42)
}
// Output:
// Hello 42
================================================
FILE: _test/import3.go
================================================
package main
import "github.com/traefik/yaegi/_test/foo"
func main() { println(foo.Bar, foo.Boo) }
// Output:
// init boo
// init foo
// BARR Boo
================================================
FILE: _test/import4.go
================================================
package main
import "github.com/traefik/yaegi/_test/p1"
func main() { println("num:", p1.Uint32()) }
// Output:
// num: 2596996162
================================================
FILE: _test/import5.go
================================================
package main
import boo "github.com/traefik/yaegi/_test/foo"
func main() { println(boo.Bar, boo.Boo, boo.Bir) }
// Output:
// init boo
// init foo
// BARR Boo Boo22
================================================
FILE: _test/import6.go
================================================
package main
import "github.com/traefik/yaegi/_test/c1"
func main() {
println(c1.C1)
}
// Error:
// import cycle not allowed
// imports github.com/traefik/yaegi/_test/c1
================================================
FILE: _test/import7.go
================================================
package main
import bar "github.com/traefik/yaegi/_test/foo-bar"
func main() {
println(bar.Name)
}
// Output:
// foo-bar
================================================
FILE: _test/import8.go
================================================
package main
import "github.com/traefik/yaegi/_test/b1/foo"
func main() {
println(foo.Desc)
}
// Output:
// in b1/foo
================================================
FILE: _test/import9.go
================================================
package main
import "github.com/traefik/yaegi/_test/baz-bat"
func main() {
println(baz.Name)
}
// Output:
// baz-bat
================================================
FILE: _test/inc.go
================================================
package main
func main() {
i := 2
//i++
i = i + 1
println(i)
}
// Output:
// 3
================================================
FILE: _test/inception.go
================================================
package main
import (
"log"
"github.com/traefik/yaegi/interp"
)
func main() {
log.SetFlags(log.Lshortfile)
i := interp.New(interp.Options{})
i.Use(interp.Symbols)
if _, err := i.Eval(`import "github.com/traefik/yaegi/interp"`); err != nil {
log.Fatal(err)
}
if _, err := i.Eval(`i := interp.New(interp.Options{})`); err != nil {
log.Fatal(err)
}
if _, err := i.Eval(`i.Eval("println(42)")`); err != nil {
log.Fatal(err)
}
}
================================================
FILE: _test/init0.go
================================================
package main
func init() {
println("Hello from init 1")
}
func init() {
println("Hello from init 2")
}
func main() {
println("Hello from main")
}
// Output:
// Hello from init 1
// Hello from init 2
// Hello from main
================================================
FILE: _test/init1.go
================================================
package main
func init() {
println("here")
}
func main() {
init()
}
// Error:
// _test/init1.go:8:2: undefined: init
================================================
FILE: _test/interface0.go
================================================
package main
type sample struct {
count int
}
func run(inf interface{}, name string) {
x := inf.(sample)
println(x.count, name)
}
func main() {
a := sample{2}
println(a.count)
run(a, "truc")
}
// Output:
// 2
// 2 truc
================================================
FILE: _test/interface1.go
================================================
package main
import "fmt"
type fii interface {
Hello()
}
type Boo struct {
Name string
}
func (b *Boo) Hello() {
fmt.Println("Hello", b)
fmt.Println(b.Name)
}
func inCall(foo fii) {
fmt.Println("inCall")
foo.Hello()
}
func main() {
fmt.Println("in")
boo := &Boo{"foo"}
inCall(boo)
}
// Output:
// in
// inCall
// Hello &{foo}
// foo
================================================
FILE: _test/interface10.go
================================================
package main
type Edge interface {
ReverseEdge() Edge
}
func main() {
println("hello")
}
// Output:
// hello
================================================
FILE: _test/interface11.go
================================================
package main
import "fmt"
type Error interface {
error
Code() string
}
type MyError Error
type T struct {
Name string
}
func (t *T) Error() string { return "err: " + t.Name }
func (t *T) Code() string { return "code: " + t.Name }
func newT(s string) MyError { return &T{s} }
func main() {
t := newT("foo")
fmt.Println(t.Code())
}
// Output:
// code: foo
================================================
FILE: _test/interface12.go
================================================
package main
type I1 interface {
Truc()
}
type T1 struct{}
func (T1) Truc() { println("in T1 truc") }
var x I1 = T1{}
func main() {
x.Truc()
}
// Output:
// in T1 truc
================================================
FILE: _test/interface13.go
================================================
package main
import (
"fmt"
)
type X struct{}
func (X) Foo() int {
return 1
}
func (X) Bar() int {
return 2
}
type Foo interface {
Foo() int
}
type Bar interface {
Bar() int
}
func main() {
var x X
var i Foo = x
j := i.(Bar)
fmt.Println(j.Bar())
}
// Output:
// 2
================================================
FILE: _test/interface14.go
================================================
package main
type T struct{}
func (t *T) Error() string { return "T: error" }
var invalidT = &T{}
func main() {
var err error
if err != invalidT {
println("ok")
}
}
// Output:
// ok
================================================
FILE: _test/interface15.go
================================================
package main
type Fooer interface {
Foo() string
}
type Barer interface {
//fmt.Stringer
Fooer
Bar()
}
type T struct{}
func (t *T) Foo() string { return "T: foo" }
func (*T) Bar() { println("in bar") }
var t = &T{}
func main() {
var f Barer
if f != t {
println("ok")
}
}
// Output:
// ok
================================================
FILE: _test/interface16.go
================================================
package main
import "fmt"
type Barer interface {
fmt.Stringer
Bar()
}
type T struct{}
func (*T) String() string { return "T: nothing" }
func (*T) Bar() { println("in bar") }
var t = &T{}
func main() {
var f Barer
if f != t {
println("ok")
}
}
// Output:
// ok
================================================
FILE: _test/interface17.go
================================================
package main
type T struct{}
func (t T) Error() string { return "T: error" }
var invalidT = T{}
func main() {
var err error
if err != invalidT {
println("ok")
}
}
// Output:
// ok
================================================
FILE: _test/interface18.go
================================================
package main
type T struct{}
func (t *T) Error() string { return "T: error" }
func (*T) Foo() { println("foo") }
var invalidT = &T{}
func main() {
var err error
if err != invalidT {
println("ok")
}
}
// Output:
// ok
================================================
FILE: _test/interface19.go
================================================
package main
import "fmt"
var I interface{}
func main() {
fmt.Printf("%T %v\n", I, I)
}
// Output:
// <nil> <nil>
================================================
FILE: _test/interface2.go
================================================
package main
import "fmt"
type fii interface {
Hello()
}
type Boo struct {
Name string
}
type Bar struct{}
func (b Bar) Hello() { fmt.Println("b:", b) }
func (b Boo) Hello() {
fmt.Println("Hello", b)
fmt.Println(b.Name)
}
func inCall(foo fii) {
fmt.Println("inCall")
switch a := foo.(type) {
case Boo:
a.Hello()
default:
fmt.Println("a:", a)
}
}
func main() {
boo := Boo{"foo"}
inCall(boo)
inCall(Bar{})
}
// Output:
// inCall
// Hello {foo}
// foo
// inCall
// a: {}
================================================
FILE: _test/interface20.go
================================================
package main
import "fmt"
func main() {
var a interface{}
a = string("A")
fmt.Println(a)
}
// Output:
// A
================================================
FILE: _test/interface21.go
================================================
package main
import "fmt"
func main() {
s := make([]interface{}, 1)
s[0] = 1
fmt.Println(s[0])
}
// Output:
// 1
================================================
FILE: _test/interface22.go
================================================
package main
import "fmt"
func main() {
s := make([]interface{}, 0)
s = append(s, 1)
fmt.Println(s[0])
}
// Output:
// 1
================================================
FILE: _test/interface23.go
================================================
package main
import "fmt"
func main() {
m := make(map[string]interface{})
m["A"] = string("A")
fmt.Println(m["A"])
}
// Output:
// A
================================================
FILE: _test/interface24.go
================================================
package main
import "fmt"
func main() {
m := make(map[string]interface{})
fmt.Println(m["B"])
}
// Output:
// <nil>
================================================
FILE: _test/interface25.go
================================================
package main
import "fmt"
func main() {
m := make(map[string]interface{})
m["A"] = 1
for _, v := range m {
fmt.Println(v)
}
}
// Output:
// 1
================================================
FILE: _test/interface26.go
================================================
package main
import "fmt"
func main() {
s := make([]interface{}, 0)
s = append(s, 1)
for _, v := range s {
fmt.Println(v)
}
}
// Output:
// 1
================================================
FILE: _test/interface27.go
================================================
package main
import "fmt"
var errs = map[int]error{0: nil}
func main() {
fmt.Println(errs)
}
// Output:
// map[0:<nil>]
================================================
FILE: _test/interface28.go
================================================
package main
import "fmt"
var errs = []error{nil}
func main() {
fmt.Println(errs)
}
// Output:
// [<nil>]
================================================
FILE: _test/interface29.go
================================================
package main
func main() {
var a interface{}
println(a == nil)
}
// Output:
// true
================================================
FILE: _test/interface3.go
================================================
package main
import "fmt"
type fii interface {
Hello()
}
type Boo struct {
Name string
}
func (b Boo) Hello() {
fmt.Println("Hello", b)
fmt.Println(b.Name)
}
func inCall(foo fii) {
fmt.Println("inCall")
foo.Hello()
}
func main() {
boo := Boo{"foo"}
inCall(boo)
}
// Output:
// inCall
// Hello {foo}
// foo
================================================
FILE: _test/interface30.go
================================================
package main
func main() {
var a interface{}
println(a != nil)
}
// Output:
// false
================================================
FILE: _test/interface31.go
================================================
package main
import "fmt"
func main() {
s := []interface{}{"test", 2}
fmt.Println(s[0], s[1])
}
// Output:
// test 2
================================================
FILE: _test/interface32.go
================================================
package main
import "fmt"
func main() {
s := [2]interface{}{"test", 2}
fmt.Println(s[0], s[1])
}
// Output:
// test 2
================================================
FILE: _test/interface33.go
================================================
package main
import "fmt"
func main() {
var a = map[string]interface{}{"test": "test"}
fmt.Println(a["test"])
}
// Output:
// test
================================================
FILE: _test/interface34.go
================================================
package main
import "fmt"
func main() {
s := [2]interface{}{1: "test", 0: 2}
fmt.Println(s[0], s[1])
}
// Output:
// 2 test
================================================
FILE: _test/interface35.go
================================================
package main
import "fmt"
type T struct {
I interface{}
}
func main() {
t := T{"test"}
fmt.Println(t)
}
// Output:
// {test}
================================================
FILE: _test/interface36.go
================================================
package main
import "fmt"
var (
t *S
_ I = t
_ J = t
)
type S struct {
Name string
}
func (s *S) F() int { return len(s.Name) }
func (s *S) G() int { return s.F() }
func (s *S) Ri() I { return s }
func (s *S) Rj() J { return s }
type J interface {
I
G() int
Rj() J
}
type I interface {
F() int
Ri() I
}
func main() {
var j J
fmt.Println(j)
}
// Output:
// <nil>
================================================
FILE: _test/interface37.go
================================================
package main
type I interface {
A() string
B() string
}
type s struct{}
func NewS() (I, error) {
return &s{}, nil
}
func (c *s) A() string { return "a" }
func (c *s) B() string { return "b" }
func main() {
s, _ := NewS()
println(s.A())
}
// Output:
// a
================================================
FILE: _test/interface38.go
================================================
package main
import "fmt"
type foo struct {
bar string
}
func (f foo) String() string {
return "Hello from " + f.bar
}
func main() {
var f fmt.Stringer = foo{bar: "bar"}
fmt.Println(f)
}
// Output:
// Hello from bar
================================================
FILE: _test/interface39.go
================================================
package main
import "fmt"
type foo struct {
bar string
}
func (f *foo) String() string {
return "Hello from " + f.bar
}
func main() {
var f fmt.Stringer = &foo{bar: "bar"}
fmt.Println(f)
}
// Output:
// Hello from bar
================================================
FILE: _test/interface4.go
================================================
package main
import "fmt"
type fii interface {
Hello()
}
type Boo struct {
Name string
}
type Bir struct {
Boo
}
func (b Boo) Hello() {
fmt.Println("Hello", b)
fmt.Println(b.Name)
}
func inCall(foo fii) {
fmt.Println("inCall")
foo.Hello()
}
func main() {
bir := Bir{Boo{"foo"}}
inCall(bir)
}
// Output:
// inCall
// Hello {foo}
// foo
================================================
FILE: _test/interface40.go
================================================
package main
import "fmt"
type foo struct {
bar string
}
func (f foo) String() string {
return "Hello from " + f.bar
}
func Foo(s string) fmt.Stringer {
return foo{s}
}
func main() {
f := Foo("bar")
fmt.Println(f)
}
// Output:
// Hello from bar
================================================
FILE: _test/interface41.go
================================================
package main
import "fmt"
type foo struct {
bar string
}
func (f *foo) String() string {
return "Hello from " + f.bar
}
func Foo(s string) fmt.Stringer {
return &foo{s}
}
func main() {
f := Foo("bar")
fmt.Println(f)
}
// Output:
// Hello from bar
================================================
FILE: _test/interface42.go
================================================
package main
import "fmt"
func main() {
v := interface{}(0)
fmt.Println(v)
}
// Output:
// 0
================================================
FILE: _test/interface43.go
================================================
package main
import "fmt"
func main() {
v := interface{}(nil)
fmt.Println(v)
}
// Output:
// <nil>
================================================
FILE: _test/interface44.go
================================================
package main
type S struct {
a int
}
func main() {
var i interface{} = S{a: 1}
s, ok := i.(S)
if !ok {
println("bad")
return
}
println(s.a)
}
// Output:
// 1
================================================
FILE: _test/interface45.go
================================================
package main
import "fmt"
func main() {
var i interface{} = 1
var s struct{}
s, _ = i.(struct{})
fmt.Println(s)
}
// Output:
// {}
================================================
FILE: _test/interface46.go
================================================
package main
import "fmt"
type I interface {
Foo() string
}
type Printer struct {
i I
}
func New(i I) *Printer {
return &Printer{
i: i,
}
}
func (p *Printer) Print() {
fmt.Println(p.i.Foo())
}
type T struct{}
func (t *T) Foo() string {
return "test"
}
func main() {
g := New(&T{})
g.Print()
}
// Output:
// test
================================================
FILE: _test/interface47.go
================================================
package main
type Doer interface {
Do() error
}
type T struct {
Name string
}
func (t *T) Do() error { println("in do"); return nil }
func f() (Doer, error) { return &T{"truc"}, nil }
type Ev struct {
doer func() (Doer, error)
}
func (e *Ev) do() {
d, _ := e.doer()
d.Do()
}
func main() {
e := &Ev{f}
println(e != nil)
e.do()
}
// Output:
// true
// in do
================================================
FILE: _test/interface48.go
================================================
package main
import "fmt"
type I1 interface{ A }
type A = I2
type I2 interface{ F() I1 }
func main() {
var i I1
fmt.Println(i)
}
// Output:
// <nil>
================================================
FILE: _test/interface49.go
================================================
package main
type Descriptor interface {
ParentFile() FileDescriptor
}
type FileDescriptor interface {
Enums() EnumDescriptors
Services() ServiceDescriptors
}
type EnumDescriptors interface {
Get(i int) EnumDescriptor
}
type EnumDescriptor interface {
Values() EnumValueDescriptors
}
type EnumValueDescriptors interface {
Get(i int) EnumValueDescriptor
}
type EnumValueDescriptor interface {
Descriptor
}
type ServiceDescriptors interface {
Get(i int) ServiceDescriptor
}
type ServiceDescriptor interface {
Descriptor
isServiceDescriptor
}
type isServiceDescriptor interface{ ProtoType(ServiceDescriptor) }
func main() {
var d Descriptor
println(d == nil)
}
// Output:
// true
================================================
FILE: _test/interface5.go
================================================
package main
import "fmt"
type Myint int
func (i Myint) Double() { fmt.Println("Myint:", i, i) }
type Boo interface {
Double()
}
func f(boo Boo) {
boo.Double()
}
func main() {
var i Myint = 3
f(i)
}
// Output:
// Myint: 3 3
================================================
FILE: _test/interface50.go
================================================
package main
func main() {
a := true
var b interface{} = 5
println(b.(int))
b = a == true
println(b.(bool))
}
// Output:
// 5
// true
================================================
FILE: _test/interface51.go
================================================
package main
type Error interface {
error
Message() string
}
type T struct {
Msg string
}
func (t *T) Error() string { return t.Msg }
func (t *T) Message() string { return "message:" + t.Msg }
func newError() Error { return &T{"test"} }
func main() {
e := newError()
println(e.Error())
}
// Output:
// test
================================================
FILE: _test/interface52.go
================================================
package main
import "testing"
func main() {
t := testing.T{}
var tb testing.TB
tb = &t
if tb.TempDir() == "" {
println("FAIL")
return
}
println("PASS")
}
// Output:
// PASS
================================================
FILE: _test/interface6.go
================================================
package main
import "fmt"
type Myint int
func (i Myint) Double() { fmt.Println("Myint:", i, i) }
type Boo interface {
Double()
}
func f(boo Boo) { boo.Double() }
func g(i int) Boo { return Myint(i) }
func main() {
f(g(4))
}
// Output:
// Myint: 4 4
================================================
FILE: _test/interface7.go
================================================
package main
import "fmt"
type T int
func (t T) Error() string { return fmt.Sprintf("This is an error from T: %d", t) }
func f(t T) error { return t }
func main() {
x := T(1)
fmt.Println(f(x))
}
// Output:
// This is an error from T: 1
================================================
FILE: _test/interface8.go
================================================
package main
import (
"fmt"
)
var _ = (HelloInterface)((*Hello)(nil))
type HelloInterface interface {
Hi() string
}
type Hello struct{}
func (h *Hello) Hi() string {
return "hi"
}
func main() {
h := &Hello{}
fmt.Println(h.Hi())
}
// Output:
// hi
================================================
FILE: _test/interface9.go
================================================
package main
import "fmt"
type Int int
func (I Int) String() string {
return "foo"
}
func main() {
var i Int
var st fmt.Stringer = i
fmt.Println(st.String())
}
// Output:
// foo
================================================
FILE: _test/interp.gi
================================================
package main
import (
"github.com/traefik/yaegi/interp"
)
func main() {
i := interp.New(interp.Opt{})
i.Eval(`println("Hello")`)
}
// Output:
// Hello
================================================
FILE: _test/interp2.gi
================================================
package main
import (
"github.com/traefik/yaegi/interp"
)
func main() {
i := interp.New(interp.Opt{})
i.Use(interp.ExportValue, interp.ExportType)
i.Eval(`import "github.com/traefik/yaegi/interp"`)
i.Eval(`i := interp.New(interp.Opt{})`)
i.Eval(`i.Eval("println(42)")`)
}
// Output:
// 42
================================================
FILE: _test/io0.go
================================================
package main
import (
"crypto/rand"
"fmt"
"io"
)
func main() {
var buf [16]byte
fmt.Println(buf)
io.ReadFull(rand.Reader, buf[:])
//io.ReadFull(rand.Reader, buf)
fmt.Println(buf)
}
================================================
FILE: _test/io1.go
================================================
package main
import (
"encoding/base64"
"fmt"
)
func main() {
var buf [4]byte
s := base64.RawStdEncoding.EncodeToString(buf[:])
fmt.Println(s)
}
// Output:
// AAAAAA
================================================
FILE: _test/io2.go
================================================
package main
import (
"fmt"
"io"
"log"
"strings"
)
func main() {
r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
b, err := io.ReadAll(r)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", b)
}
// Output:
// Go is a general-purpose language designed with systems programming in mind.
================================================
FILE: _test/iota.go
================================================
package main
import "fmt"
const (
Foo = iota
Bar
Baz
)
const (
Asm = iota
C
Java
Go
)
func main() {
fmt.Println(Foo, Bar, Baz)
fmt.Println(Asm, C, Java, Go)
}
// Output:
// 0 1 2
// 0 1 2 3
================================================
FILE: _test/iota0.go
================================================
package main
import "fmt"
func main() {
const (
Foo = iota
Bar
Baz
)
const (
Asm = iota
C
Java
Go
)
fmt.Println(Foo, Bar, Baz)
fmt.Println(Asm, C, Java, Go)
}
// Output:
// 0 1 2
// 0 1 2 3
================================================
FILE: _test/ipp_as_key.go
================================================
package main
import (
"guthib.com/toto" // pkg name is actually titi
"guthib.com/tata" // pkg name is actually tutu
)
func main() {
println("Hello", titi.Quux())
println("Hello", tutu.Quux())
}
// GOPATH:testdata/redeclaration-global7
// Output:
// Hello bar
// Hello baz
================================================
FILE: _test/issue-1007.go
================================================
package main
type TypeA struct {
B TypeB
}
type TypeB struct {
C1 *TypeC
C2 *TypeC
}
type TypeC struct {
Val string
D *TypeD
D2 *TypeD
}
type TypeD struct {
Name string
}
func build() *TypeA {
return &TypeA{
B: TypeB{
C2: &TypeC{Val: "22"},
},
}
}
func Bar(s string) string {
a := build()
return s + "-" + a.B.C2.Val
}
func main() {
println(Bar("test"))
}
// Output:
// test-22
================================================
FILE: _test/issue-1010.go
================================================
package main
import (
"encoding/json"
"fmt"
)
type MyJsonMarshaler struct{ n int }
func (m MyJsonMarshaler) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf(`{"num": %d}`, m.n)), nil
}
func main() {
ch := make(chan json.Marshaler, 1)
ch <- MyJsonMarshaler{2}
m, err := json.Marshal(<-ch)
fmt.Println(string(m), err)
}
// Output:
// {"num":2} <nil>
================================================
FILE: _test/issue-1022.go
================================================
package main
import "fmt"
func main() {
defer func() {
r := recover()
if r != nil {
fmt.Println(r)
}
}()
panic("Ho Ho Ho!")
}
// Output:
// Ho Ho Ho!
================================================
FILE: _test/issue-1052.go
================================================
package main
import "fmt"
func main() {
a, b := 1, 1
for i := 0; i < 10; i++ {
fmt.Println(a)
a, b = b, a+b
}
}
// Output:
// 1
// 1
// 2
// 3
// 5
// 8
// 13
// 21
// 34
// 55
================================================
FILE: _test/issue-1065.go
================================================
package main
import "fmt"
type AST struct {
Num int
Children []AST
}
func newAST(num int, root AST, children ...AST) AST {
return AST{num, append([]AST{root}, children...)}
}
func main() {
ast := newAST(1, AST{}, AST{})
fmt.Println(ast)
}
// Output:
// {1 [{0 []} {0 []}]}
================================================
FILE: _test/issue-1068.go
================================================
package main
type I interface {
Hello()
}
type T struct{}
func (t T) Hello() { println("hello") }
type I2 I
func main() {
var i I2 = T{}
i.Hello()
}
// Output:
// hello
================================================
FILE: _test/issue-1088.go
================================================
package main
import "fmt"
func main() {
for i, ch := range "日本語" {
fmt.Printf("%#U starts at byte position %d\n", ch, i)
}
}
// Output:
// U+65E5 '日' starts at byte position 0
// U+672C '本' starts at byte position 3
// U+8A9E '語' starts at byte position 6
================================================
FILE: _test/issue-1089.go
================================================
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println(`"` + time.RFC3339Nano + `"`)
}
// Output:
// "2006-01-02T15:04:05.999999999Z07:00"
================================================
FILE: _test/issue-1093.go
================================================
package main
func b() string {
return "b"
}
func main() {
var x int
x = "a" + b()
}
// Error:
// 9:6: cannot use type untyped string as type int in assignment
================================================
FILE: _test/issue-1094.go
================================================
package main
import "fmt"
func main() {
var x interface{}
x = "a" + fmt.Sprintf("b")
fmt.Printf("%v %T\n", x, x)
}
// Output:
// ab string
================================================
FILE: _test/issue-1101.go
================================================
package main
import (
"fmt"
"net/http"
)
func main() {
method := "POST"
switch method {
case http.MethodPost:
fmt.Println("It's a post!")
}
}
// Output:
// It's a post!
================================================
FILE: _test/issue-1115.go
================================================
package main
import "fmt"
func main() {
outer:
for y := 0; y < 10; y++ {
for x := 0; x < 10; x++ {
if x == 5 && y == 5 {
break outer
}
}
fmt.Println(y)
}
fmt.Println("Yay! I finished!")
}
// Output:
// 0
// 1
// 2
// 3
// 4
// Yay! I finished!
================================================
FILE: _test/issue-1126.go
================================================
package main
import (
"errors"
"fmt"
"strings"
)
func main() {
err := errors.New("hello there")
switch true {
case err == nil:
break
case strings.Contains(err.Error(), "hello"):
fmt.Println("True!")
default:
fmt.Println("False!")
}
}
// Output:
// True!
================================================
FILE: _test/issue-1128.go
================================================
package main
import "net"
func main() {
c := append(net.Buffers{}, []byte{})
println(len(c))
}
// Output:
// 1
================================================
FILE: _test/issue-1134.go
================================================
package main
type I interface {
Hello()
}
type T struct {
Name string
Child []*T
}
func (t *T) Hello() { println("Hello", t.Name) }
func main() {
var i I = new(T)
i.Hello()
}
// Output:
// Hello
================================================
FILE: _test/issue-1136.go
================================================
package main
import (
"fmt"
"io"
)
type T struct {
r io.Reader
}
func (t *T) Read(p []byte) (n int, err error) { n, err = t.r.Read(p); return }
func main() {
x := io.LimitedReader{}
y := io.Reader(&x)
y = &T{y}
fmt.Println(y.Read([]byte("")))
}
// Output:
// 0 EOF
================================================
FILE: _test/issue-1145.go
================================================
package main
import "sync"
type F func()
func main() {
var wg sync.WaitGroup
var f F = wg.Done
println(f != nil)
}
// Output:
// true
================================================
FILE: _test/issue-1156.go
================================================
package main
type myInterface interface {
myFunc() string
}
type V struct{}
func (v *V) myFunc() string { return "hello" }
type U struct {
v myInterface
}
func (u *U) myFunc() string { return u.v.myFunc() }
func main() {
x := V{}
y := myInterface(&x)
y = &U{y}
println(y.myFunc())
}
// Output:
// hello
================================================
FILE: _test/issue-1163.go
================================================
package main
import "fmt"
type WidgetEvent struct {
Nothing string
}
type WidgetControl interface {
HandleEvent(e *WidgetEvent)
}
type Button struct{}
func (b *Button) HandleEvent(e *WidgetEvent) {
}
type WindowEvent struct {
Something int
}
type Window struct {
Widget WidgetControl
}
func (w *Window) HandleEvent(e *WindowEvent) {
}
func main() {
window := &Window{
Widget: &Button{},
}
windowevent := &WindowEvent{}
// The next line uses the signature from the wrong method, resulting in an error.
// Renaming one of the clashing method names fixes the problem.
window.HandleEvent(windowevent)
fmt.Println("OK!")
}
// Output:
// OK!
================================================
FILE: _test/issue-1166.go
================================================
package main
import (
"fmt"
"io"
)
type T []byte
func (t *T) Write(p []byte) (n int, err error) { *t = append(*t, p...); return len(p), nil }
func foo(w io.Writer) {
a := w.(*T)
fmt.Fprint(a, "test")
fmt.Printf("%s\n", *a)
}
func main() {
x := T{}
foo(&x)
}
// Output:
// test
================================================
FILE: _test/issue-1167.go
================================================
package main
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
)
func main() {
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
panic(err)
}
pub := key.Public().(*ecdsa.PublicKey)
println(pub.Params().Name)
}
// Output:
// P-256
================================================
FILE: _test/issue-1173.go
================================================
package main
var real = func() { println("Hello") }
func main() {
real()
}
// Output:
// Hello
================================================
FILE: _test/issue-1175.go
================================================
package main
type Level int8
const (
a Level = -1
b Level = 5
d = b - a + 1
)
type counters [d]int
func main() {
println(len(counters{}))
}
// Output:
// 7
================================================
FILE: _test/issue-1177.go
================================================
package main
type counters [3][16]int
func main() {
cs := &counters{}
p := &cs[0][1]
*p = 2
println(cs[0][1])
}
// Output:
// 2
================================================
FILE: _test/issue-1179.go
================================================
package main
type I interface {
F()
}
type T struct {
Name string
}
func (t *T) F() { println("in F", t.Name) }
func NewI(s string) I { return newT(s) }
func newT(s string) *T { return &T{s} }
func main() {
i := NewI("test")
i.F()
}
// Output:
// in F test
================================================
FILE: _test/issue-1181.go
================================================
package main
func main() {
a, b := 1, 2
a, b = b, -a
println(a, b)
}
// Output:
// 2 -1
================================================
FILE: _test/issue-1185.go
================================================
package main
import "io"
type B []byte
func (b B) Write(p []byte) (n int, err error) {
b = p
return len(p), nil
}
func main() {
b := B{}
a := make([]io.Writer, 0)
a = append(a, b)
println(len(a))
}
// Output:
// 1
================================================
FILE: _test/issue-1187.go
================================================
package main
import (
"io"
"os"
)
type sink interface {
io.Writer
io.Closer
}
func newSink() sink {
// return os.Stdout // Stdout is special in yaegi tests
file, err := os.CreateTemp("", "yaegi-test.*")
if err != nil {
panic(err)
}
return file
}
func main() {
s := newSink()
n, err := s.Write([]byte("Hello\n"))
if err != nil {
panic(err)
}
var writer io.Writer = s
m, err := writer.Write([]byte("Hello\n"))
if err != nil {
panic(err)
}
var closer io.Closer = s
err = closer.Close()
if err != nil {
panic(err)
}
err = os.Remove(s.(*os.File).Name())
if err != nil {
panic(err)
}
println(m, n)
}
// Output:
// 6 6
================================================
FILE: _test/issue-1189.go
================================================
package main
type I interface {
Foo() int
}
type S1 struct {
i int
}
func (s S1) Foo() int { return s.i }
type S2 struct{}
func (s *S2) Foo() int { return 42 }
func main() {
Is := map[string]I{
"foo": S1{21},
"bar": &S2{},
}
n := 0
for _, s := range Is {
n += s.Foo()
}
bar := "bar"
println(n, Is["foo"].Foo(), Is[bar].Foo())
}
// Output:
// 63 21 42
================================================
FILE: _test/issue-1202.go
================================================
package main
import "fmt"
type foobar struct {
callback func(string) func()
}
func cb(text string) func() {
return func() {
fmt.Println(text)
}
}
func main() {
// These ways of invoking it all work...
cb("Hi from inline callback!")()
asVarTest1 := cb("Hi from asVarTest1 callback!")
asVarTest1()
asVarTest2 := cb
asVarTest2("Hi from asVarTest2 callback!")()
// But inside a struct panics in yaegi...
asStructField := &foobar{callback: cb}
asStructField.callback("Hi from struct field callback!")() // <--- panics here
}
// Output:
// Hi from inline callback!
// Hi from asVarTest1 callback!
// Hi from asVarTest2 callback!
// Hi from struct field callback!
================================================
FILE: _test/issue-1205.go
================================================
package main
type Option interface {
apply()
}
func f(opts ...Option) {
for _, opt := range opts {
opt.apply()
}
}
type T struct{}
func (t *T) apply() { println("in apply") }
func main() {
opt := []Option{&T{}}
f(opt[0]) // works
f(opt...) // fails
}
// Output:
// in apply
// in apply
================================================
FILE: _test/issue-1208.go
================================================
package main
type Enabler interface {
Enabled() bool
}
type Logger struct {
core Enabler
}
func (log *Logger) GetCore() Enabler { return log.core }
type T struct{}
func (t *T) Enabled() bool { return true }
func main() {
base := &Logger{&T{}}
println(base.GetCore().Enabled())
}
// Output:
// true
================================================
FILE: _test/issue-1260.go
================================================
package main
import (
"fmt"
"io"
"os"
)
type WriteSyncer interface {
io.Writer
Sync() error
}
type Sink interface {
WriteSyncer
io.Closer
}
func newFileSink(path string) (Sink, error) {
return os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
}
type Sink1 struct{ name string }
func (s Sink1) Write(b []byte) (int, error) { println("in Write"); return 0, nil }
func (s Sink1) Sync() error { println("in Sync"); return nil }
func (s Sink1) Close() error { println("in Close", s.name); return nil }
func newS1(name string) Sink { return Sink1{name} }
func newS1p(name string) Sink { return &Sink1{name} }
type Sink2 struct{ name string }
func (s *Sink2) Write(b []byte) (int, error) { println("in Write"); return 0, nil }
func (s *Sink2) Sync() error { println("in Sync"); return nil }
func (s *Sink2) Close() error { println("in Close", s.name); return nil }
func newS2(name string) Sink { return Sink1{name} }
func main() {
tmpfile, err := os.CreateTemp("", "xxx")
if err != nil {
panic(err)
}
defer os.Remove(tmpfile.Name())
closers := []io.Closer{}
sink, err := newFileSink(tmpfile.Name())
if err != nil {
panic(err)
}
closers = append(closers, sink)
s1p := newS1p("ptr")
s1 := newS1("struct")
s2 := newS2("ptr2")
closers = append(closers, s1p, s1, s2)
for _, closer := range closers {
fmt.Println(closer.Close())
}
}
// Output:
// <nil>
// in Close ptr
// <nil>
// in Close struct
// <nil>
// in Close ptr2
// <nil>
================================================
FILE: _test/issue-1276.go
================================================
package main
import (
"flag"
)
type customFlag struct{}
func (cf customFlag) String() string {
return "custom flag"
}
func (cf customFlag) Set(string) error {
return nil
}
func main() {
flag.Var(customFlag{}, "cf", "custom flag")
flag.Parse()
println("Hello, playground")
}
// Output:
// Hello, playground
================================================
FILE: _test/issue-1280.go
================================================
package main
import (
"io"
"log"
"os"
)
type DBReader interface {
io.ReadCloser
io.ReaderAt
}
type DB struct {
f DBReader
}
func main() {
f, err := os.Open(os.DevNull)
if err != nil {
log.Fatal(err)
}
d := &DB{f}
data := make([]byte, 1)
_, _ = d.f.ReadAt(data, 0)
println("bye")
}
// Output:
// bye
================================================
FILE: _test/issue-1285.go
================================================
package main
type (
T1 struct{ Path [12]int8 }
T2 struct{ Path *[12]int8 }
)
var (
t11 = &T1{}
t21 = &T2{}
)
func main() {
b := [12]byte{}
t12 := &T1{}
t22 := &T2{}
b11 := (*[len(t11.Path)]byte)(&b)
b12 := (*[len(t12.Path)]byte)(&b)
b21 := (*[len(t21.Path)]byte)(&b)
b22 := (*[len(t22.Path)]byte)(&b)
println(len(b11), len(b12), len(b21), len(b22))
}
// Output:
// 12 12 12 12
================================================
FILE: _test/issue-1288.go
================================================
package main
func main() {
println("Hi")
goto done
done:
}
// Output:
// Hi
================================================
FILE: _test/issue-1300.go
================================================
package main
const buflen = 512
type T struct {
buf []byte
}
func f(t *T) { *t = T{buf: make([]byte, 0, buflen)} }
func main() {
s := T{}
println(cap(s.buf))
f(&s)
println(cap(s.buf))
}
// Output:
// 0
// 512
================================================
FILE: _test/issue-1304.go
================================================
package main
type Node struct {
Name string
Alias *Node
Child []*Node
}
func main() {
n := &Node{Name: "parent"}
n.Child = append(n.Child, &Node{Name: "child"})
println(n.Name, n.Child[0].Name)
}
// Output:
// parent child
================================================
FILE: _test/issue-1306.go
================================================
package main
import "fmt"
func check() (result bool, err error) {
return true, nil
}
func main() {
result, error := check()
fmt.Println(result, error)
}
// Output:
// true <nil>
================================================
FILE: _test/issue-1308.go
================================================
package main
import "fmt"
type test struct {
v interface{}
s string
}
type T struct {
name string
}
func main() {
t := []test{
{
v: []interface{}{
T{"hello"},
},
s: "world",
},
}
fmt.Println(t)
}
// Output:
// [{[{hello}] world}]
================================================
FILE: _test/issue-1311.go
================================================
package main
type T struct {
v interface{}
}
func f() (ret int64, err error) {
ret += 2
return
}
func main() {
t := &T{}
t.v, _ = f()
println(t.v.(int64))
}
// Output:
// 2
================================================
FILE: _test/issue-1315.go
================================================
package main
type Intf interface {
M()
}
type T struct {
s string
}
func (t *T) M() { println("in M") }
func f(i interface{}) {
switch j := i.(type) {
case Intf:
j.M()
default:
println("default")
}
}
func main() {
var i Intf
var k interface{} = 1
i = &T{"hello"}
f(i)
f(k)
}
// Output:
// in M
// default
================================================
FILE: _test/issue-1320.go
================================================
package main
type Pooler interface {
Get() string
}
type baseClient struct {
connPool Pooler
}
type connPool struct {
name string
}
func (c *connPool) Get() string { return c.name }
func newBaseClient(i int, p Pooler) *baseClient {
return &baseClient{connPool: p}
}
func newConnPool() *connPool { return &connPool{name: "connPool"} }
func main() {
b := newBaseClient(0, newConnPool())
println(b.connPool.(*connPool).name)
}
// Output:
// connPool
================================================
FILE: _test/issue-1326.go
================================================
package main
type Option interface {
apply(*T)
}
type T struct {
s string
}
type opt struct {
name string
}
func (o *opt) apply(t *T) {
println(o.name)
}
func BuildOptions() []Option {
return []Option{
&opt{"opt1"},
&opt{"opt2"},
}
}
func NewT(name string, options ...Option) *T {
t := &T{name}
for _, opt := range options {
opt.apply(t)
}
return t
}
func main() {
t := NewT("hello", BuildOptions()...)
println(t.s)
}
// Output:
// opt1
// opt2
// hello
================================================
FILE: _test/issue-1328.go
================================================
package main
import (
"crypto/sha1"
"encoding/hex"
)
func main() {
script := "hello"
sumRaw := sha1.Sum([]byte(script))
sum := hex.EncodeToString(sumRaw[:])
println(sum)
}
// Output:
// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
================================================
FILE: _test/issue-1330.go
================================================
package main
import (
"fmt"
"io"
"net"
)
type wrappedConn struct {
net.Conn
}
func main() {
_, err := net.Listen("tcp", "127.0.0.1:49153")
if err != nil {
panic(err)
}
dialer := &net.Dialer{
LocalAddr: &net.TCPAddr{
IP: net.ParseIP("127.0.0.1"),
Port: 0,
},
}
conn, err := dialer.Dial("tcp", "127.0.0.1:49153")
if err != nil {
panic(err)
}
defer conn.Close()
t := &wrappedConn{conn}
var w io.Writer = t
if n, err := w.Write([]byte("hello")); err != nil {
fmt.Println(err)
} else {
fmt.Println(n)
}
}
// Output:
// 5
================================================
FILE: _test/issue-1332.go
================================================
package main
func run(fn func(name string)) { fn("test") }
type T2 struct {
name string
}
func (t *T2) f(s string) { println(s, t.name) }
func main() {
t2 := &T2{"foo"}
run(t2.f)
}
// Output:
// test foo
================================================
FILE: _test/issue-1333.go
================================================
package main
import (
"fmt"
"io"
"net/http"
"net/http/httptest"
)
func mock(name string) http.HandlerFunc {
return func(rw http.ResponseWriter, req *http.Request) {
fmt.Fprint(rw, "Hello ", name)
}
}
func client(uri string) {
resp, err := http.Get(uri)
if err != nil {
panic(err)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println(string(body))
}
func main() {
mux := http.NewServeMux()
server := httptest.NewServer(mux)
defer server.Close()
mux.Handle("/", mock("foo"))
client(server.URL)
}
// Output:
// Hello foo
================================================
FILE: _test/issue-1337.go
================================================
package main
import (
"io"
"os"
)
func f(i interface{}) {
switch at := i.(type) {
case int, int8:
println("integer", at)
case io.Reader:
println("reader")
}
println("bye")
}
func main() {
var fd *os.File
var r io.Reader = fd
f(r)
}
// Output:
// reader
// bye
================================================
FILE: _test/issue-1342.go
================================================
package main
import "fmt"
func main() {
var a interface{}
a = "a"
fmt.Println(a, a == "a")
}
// Output:
// a true
================================================
FILE: _test/issue-1344.go
================================================
package main
import "fmt"
func main() {
var m = map[string]interface{}{"a": "a"}
a, _ := m["a"]
b, ok := a.(string)
fmt.Println("a:", a, ", b:", b, ", ok:", ok)
}
// Output:
// a: a , b: a , ok: true
================================================
FILE: _test/issue-1354.go
================================================
package main
func main() {
println(test()) // Go prints true, Yaegi false
}
func test() bool {
if true {
goto label
}
goto label
label:
println("Go continues here")
return true
println("Yaegi goes straight to this return (this line is never printed)")
return false
}
// Output:
// Go continues here
// true
================================================
FILE: _test/issue-1355.go
================================================
package main
import "github.com/traefik/yaegi/_test/p2"
func f(i interface{}) {
_, ok := i.(p2.I)
println("ok:", ok)
}
func main() {
var v *p2.T
var i interface{}
i = v
_, ok := i.(p2.I)
println("ok:", ok)
f(v)
}
// Output:
// ok: true
// ok: true
================================================
FILE: _test/issue-1360.go
================================================
package main
import (
"fmt"
. "net"
)
func main() {
v := IP{}
fmt.Println(v)
}
// Output:
// <nil>
================================================
FILE: _test/issue-1361.go
================================================
package main
import (
"fmt"
"math"
)
type obj struct {
num float64
}
type Fun func(o *obj) (r *obj, err error)
func numFun(fn func(f float64) float64) Fun {
return func(o *obj) (*obj, error) {
return &obj{fn(o.num)}, nil
}
}
func main() {
f := numFun(math.Cos)
r, err := f(&obj{})
fmt.Println(r, err)
}
// Output:
// &{1} <nil>
================================================
FILE: _test/issue-1364.go
================================================
package main
import (
"fmt"
"strconv"
)
func main() {
var value interface{}
var err error
value, err = strconv.ParseFloat("123", 64)
fmt.Println(value, err)
}
// Output:
// 123 <nil>
================================================
FILE: _test/issue-1365.go
================================================
package main
func genInt() (int, error) { return 3, nil }
func getInt() (value int) {
value, err := genInt()
if err != nil {
panic(err)
}
return
}
func main() {
println(getInt())
}
// Output:
// 3
================================================
FILE: _test/issue-1368.go
================================================
package main
const dollar byte = 36
func main() {
var c byte = 36
switch true {
case c == dollar:
println("ok")
default:
println("not ok")
}
}
// Output:
// ok
================================================
FILE: _test/issue-1371.go
================================================
package main
import "fmt"
type node struct {
parent *node
child []*node
key string
}
func main() {
root := &node{key: "root"}
root.child = nil
fmt.Println("root:", root)
}
// Output:
// root: &{<nil> [] root}
================================================
FILE: _test/issue-1373.go
================================================
package main
import (
"fmt"
"go/ast"
)
func NewBadExpr() ast.Expr {
return &ast.BadExpr{}
}
func main() {
fmt.Printf("%T\n", NewBadExpr().(*ast.BadExpr))
}
// Output:
// *ast.BadExpr
================================================
FILE: _test/issue-1375.go
================================================
package main
import "fmt"
type Option func(*Struct)
func WithOption(opt string) Option {
return func(s *Struct) {
s.opt = opt
}
}
type Struct struct {
opt string
}
func New(opts ...Option) *Struct {
s := new(Struct)
for _, opt := range opts {
opt(s)
}
return s
}
func (s *Struct) ShowOption() {
fmt.Println(s.opt)
}
func main() {
opts := []Option{
WithOption("test"),
}
s := New(opts...)
s.ShowOption()
}
// Output:
// test
================================================
FILE: _test/issue-1378.go
================================================
package main
import (
"fmt"
"time"
)
func main() {
t, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
if err != nil {
panic(err)
}
fn := func() error {
_, err := t.GobEncode()
return err
}
fmt.Println(fn())
}
// Output:
// <nil>
================================================
FILE: _test/issue-1381.go
================================================
package main
import (
"bytes"
"fmt"
)
func main() {
var bufPtrOne *bytes.Buffer
var bufPtrTwo *bytes.Buffer
var bufPtrThree *bytes.Buffer
var bufPtrFour *bytes.Buffer
for i := 0; i < 2; i++ {
bufOne := bytes.Buffer{}
bufTwo := &bytes.Buffer{}
var bufThree bytes.Buffer
bufFour := new(bytes.Buffer)
if bufPtrOne == nil {
bufPtrOne = &bufOne
} else if bufPtrOne == &bufOne {
fmt.Println("bufOne was not properly redeclared")
} else {
fmt.Println("bufOne is properly redeclared")
}
if bufPtrTwo == nil {
bufPtrTwo = bufTwo
} else if bufPtrTwo == bufTwo {
fmt.Println("bufTwo was not properly redeclared")
} else {
fmt.Println("bufTwo is properly redeclared")
}
if bufPtrThree == nil {
bufPtrThree = &bufThree
} else if bufPtrThree == &bufThree {
fmt.Println("bufThree was not properly redeclared")
} else {
fmt.Println("bufThree is properly redeclared")
}
if bufPtrFour == nil {
bufPtrFour = bufFour
} else if bufPtrFour == bufFour {
fmt.Println("bufFour was not properly redeclared")
} else {
fmt.Println("bufFour is properly redeclared")
}
}
}
// Output:
// bufOne is properly redeclared
// bufTwo is properly redeclared
// bufThree is properly redeclared
// bufFour is properly redeclared
================================================
FILE: _test/issue-1404.go
================================================
package main
type I interface {
inI()
}
type T struct {
name string
}
func (t *T) inI() {}
func main() {
var i I = &T{name: "foo"}
if i, ok := i.(*T); ok {
println(i.name)
}
}
// Output:
// foo
================================================
FILE: _test/issue-1408.go
================================================
package main
type (
Number = int32
Number2 = Number
)
func f(n Number2) { println(n) }
func main() {
var n Number = 5
f(n)
}
// Output:
// 5
================================================
FILE: _test/issue-1411.go
================================================
package main
type Number int32
func (n Number) IsValid() bool { return true }
type Number1 = Number
type Number2 = Number1
func main() {
a := Number2(5)
println(a.IsValid())
}
// Output: true
================================================
FILE: _test/issue-1416.go
==============================
gitextract_wer3ebvq/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.yml
│ │ ├── config.yml
│ │ └── feature_request.yml
│ └── workflows/
│ ├── go-cross.yml
│ ├── main.yml
│ └── release.yml
├── .gitignore
├── .golangci.yml
├── .goreleaser.yml
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── _test/
│ ├── a1.go
│ ├── a10.go
│ ├── a11.go
│ ├── a12.go
│ ├── a13.go
│ ├── a14.go
│ ├── a15.go
│ ├── a16.go
│ ├── a17.go
│ ├── a18.go
│ ├── a19.go
│ ├── a2.go
│ ├── a20.go
│ ├── a21.go
│ ├── a22.go
│ ├── a23.go
│ ├── a24.go
│ ├── a25.go
│ ├── a26.go
│ ├── a27.go
│ ├── a28.go
│ ├── a29.go
│ ├── a3.go
│ ├── a30.go
│ ├── a31.go
│ ├── a32.go
│ ├── a33.go
│ ├── a34.go
│ ├── a35.go
│ ├── a36.go
│ ├── a37.go
│ ├── a38.go
│ ├── a39.go
│ ├── a4.go
│ ├── a40.go
│ ├── a41.go
│ ├── a42.go
│ ├── a43.go
│ ├── a44.go
│ ├── a5.go
│ ├── a6.go
│ ├── a7.go
│ ├── a8.go
│ ├── a9.go
│ ├── add0.go
│ ├── add1.go
│ ├── add2.go
│ ├── addr0.go
│ ├── addr1.go
│ ├── addr2.go
│ ├── addr3.go
│ ├── addr4.go
│ ├── addr5.go
│ ├── and.go
│ ├── and0.go
│ ├── and1.go
│ ├── and2.go
│ ├── and3.go
│ ├── append0.go
│ ├── append1.go
│ ├── append2.go
│ ├── append3.go
│ ├── append4.go
│ ├── assert0.go
│ ├── assert1.go
│ ├── assert2.go
│ ├── assert3.go
│ ├── assert4.go
│ ├── assign.go
│ ├── assign0.go
│ ├── assign1.go
│ ├── assign10.go
│ ├── assign11.go
│ ├── assign12.go
│ ├── assign13.go
│ ├── assign14.go
│ ├── assign15.go
│ ├── assign16.go
│ ├── assign17.go
│ ├── assign18.go
│ ├── assign19.go
│ ├── assign2.go
│ ├── assign3.go
│ ├── assign4.go
│ ├── assign5.go
│ ├── assign6.go
│ ├── assign7.go
│ ├── assign8.go
│ ├── assign9.go
│ ├── b1/
│ │ └── foo/
│ │ └── foo.go
│ ├── b2/
│ │ └── foo/
│ │ └── foo.go
│ ├── bad0.go
│ ├── baz-bat/
│ │ └── baz-bat.go
│ ├── bin.go
│ ├── bin0.go
│ ├── bin1.go
│ ├── bin2.go
│ ├── bin3.go
│ ├── bin4.go
│ ├── bin5.go
│ ├── binstruct_ptr_map0.go
│ ├── binstruct_ptr_slice0.go
│ ├── binstruct_slice0.go
│ ├── bltn.go
│ ├── bltn0.go
│ ├── bool.go
│ ├── bool0.go
│ ├── bool1.go
│ ├── bool2.go
│ ├── bool3.go
│ ├── bool4.go
│ ├── bool5.go
│ ├── break0.go
│ ├── break1.go
│ ├── break2.go
│ ├── break3.go
│ ├── c1/
│ │ └── c1.go
│ ├── c2/
│ │ └── c2.go
│ ├── cap0.go
│ ├── chan0.go
│ ├── chan1.go
│ ├── chan10.go
│ ├── chan2.go
│ ├── chan3.go
│ ├── chan4.go
│ ├── chan5.go
│ ├── chan6.go
│ ├── chan7.go
│ ├── chan8.go
│ ├── chan9.go
│ ├── cli1.go
│ ├── cli2.go
│ ├── cli3.go
│ ├── cli4.go
│ ├── cli5.go
│ ├── cli6.go
│ ├── cli7.go
│ ├── cli8.go
│ ├── closure0.go
│ ├── closure1.go
│ ├── closure10.go
│ ├── closure11.go
│ ├── closure12.go
│ ├── closure13.go
│ ├── closure14.go
│ ├── closure15.go
│ ├── closure16.go
│ ├── closure17.go
│ ├── closure18.go
│ ├── closure19.go
│ ├── closure2.go
│ ├── closure20.go
│ ├── closure3.go
│ ├── closure4.go
│ ├── closure5.go
│ ├── closure6.go
│ ├── closure7.go
│ ├── closure8.go
│ ├── closure9.go
│ ├── comp0.go
│ ├── comp1.go
│ ├── comp2.go
│ ├── complex0.go
│ ├── complex1.go
│ ├── complex2.go
│ ├── complex3.go
│ ├── complex4.go
│ ├── composite0.go
│ ├── composite1.go
│ ├── composite10.go
│ ├── composite11.go
│ ├── composite12.go
│ ├── composite13.go
│ ├── composite14.go
│ ├── composite15.go
│ ├── composite16.go
│ ├── composite17.go
│ ├── composite18.go
│ ├── composite19.go
│ ├── composite2.go
│ ├── composite3.go
│ ├── composite4.go
│ ├── composite5.go
│ ├── composite6.go
│ ├── composite7.go
│ ├── composite8.go
│ ├── composite8bis.go
│ ├── composite9.go
│ ├── const0.go
│ ├── const1.go
│ ├── const10.go
│ ├── const11.go
│ ├── const12.go
│ ├── const13.go
│ ├── const14.go
│ ├── const15.go
│ ├── const16.go
│ ├── const17.go
│ ├── const18.go
│ ├── const19.go
│ ├── const2.go
│ ├── const20.go
│ ├── const21.go
│ ├── const22.go
│ ├── const23.go
│ ├── const24.go
│ ├── const25.go
│ ├── const26.go
│ ├── const3.go
│ ├── const4.go
│ ├── const5.go
│ ├── const6.go
│ ├── const7.go
│ ├── const8.go
│ ├── const9.go
│ ├── cont.go
│ ├── cont0.go
│ ├── cont1.go
│ ├── cont2.go
│ ├── cont3.go
│ ├── context.go
│ ├── context2.go
│ ├── convert0.go
│ ├── convert1.go
│ ├── convert2.go
│ ├── convert3.go
│ ├── copy0.go
│ ├── copy1.go
│ ├── copy2.go
│ ├── ct/
│ │ ├── ct1.go
│ │ ├── ct2.go
│ │ └── ct3.go
│ ├── ct1/
│ │ └── ct1.go
│ ├── d1/
│ │ └── d1.go
│ ├── d2/
│ │ └── d2.go
│ ├── d3.go
│ ├── defer0.go
│ ├── defer1.go
│ ├── defer2.go
│ ├── defer3.go
│ ├── defer4.go
│ ├── defer5.go
│ ├── defer6.go
│ ├── defer7.go
│ ├── defer8.go
│ ├── defer9.go
│ ├── delete0.go
│ ├── eval0.go
│ ├── export0.go
│ ├── export1.go
│ ├── factor.go
│ ├── fib.go
│ ├── fib0.go
│ ├── file_access.go
│ ├── flag0.go
│ ├── foo/
│ │ ├── bar.go
│ │ ├── bir.go
│ │ └── boo/
│ │ └── boo.go
│ ├── foo-bar/
│ │ └── foo-bar.go
│ ├── for0.go
│ ├── for1.go
│ ├── for10.go
│ ├── for11.go
│ ├── for12.go
│ ├── for13.go
│ ├── for14.go
│ ├── for15.go
│ ├── for16.go
│ ├── for17.go
│ ├── for18.go
│ ├── for19.go
│ ├── for2.go
│ ├── for3.go
│ ├── for4.go
│ ├── for5.go
│ ├── for6.go
│ ├── for7.go
│ ├── for8.go
│ ├── for9.go
│ ├── fun.go
│ ├── fun10.go
│ ├── fun11.go
│ ├── fun12.go
│ ├── fun13.go
│ ├── fun14.go
│ ├── fun15.go
│ ├── fun16.go
│ ├── fun17.go
│ ├── fun18.go
│ ├── fun19.go
│ ├── fun2.go
│ ├── fun20.go
│ ├── fun21.go
│ ├── fun22.go
│ ├── fun23.go
│ ├── fun24.go
│ ├── fun25.go
│ ├── fun26.go
│ ├── fun27.go
│ ├── fun28.go
│ ├── fun3.go
│ ├── fun4.go
│ ├── fun5.go
│ ├── fun6.go
│ ├── fun7.go
│ ├── fun8.go
│ ├── fun9.go
│ ├── gen1.go
│ ├── gen10.go
│ ├── gen11.go
│ ├── gen12.go
│ ├── gen13.go
│ ├── gen2.go
│ ├── gen3.go
│ ├── gen4.go
│ ├── gen5.go
│ ├── gen6.go
│ ├── gen7.go
│ ├── gen8.go
│ ├── gen9.go
│ ├── goto0.go
│ ├── goto1.go
│ ├── heap.go
│ ├── if.go
│ ├── if0.go
│ ├── if1.go
│ ├── if2.go
│ ├── if3.go
│ ├── if4.go
│ ├── if5.go
│ ├── if6.go
│ ├── if7.go
│ ├── imag0.go
│ ├── import0.go
│ ├── import1.go
│ ├── import2.go
│ ├── import3.go
│ ├── import4.go
│ ├── import5.go
│ ├── import6.go
│ ├── import7.go
│ ├── import8.go
│ ├── import9.go
│ ├── inc.go
│ ├── inception.go
│ ├── init0.go
│ ├── init1.go
│ ├── interface0.go
│ ├── interface1.go
│ ├── interface10.go
│ ├── interface11.go
│ ├── interface12.go
│ ├── interface13.go
│ ├── interface14.go
│ ├── interface15.go
│ ├── interface16.go
│ ├── interface17.go
│ ├── interface18.go
│ ├── interface19.go
│ ├── interface2.go
│ ├── interface20.go
│ ├── interface21.go
│ ├── interface22.go
│ ├── interface23.go
│ ├── interface24.go
│ ├── interface25.go
│ ├── interface26.go
│ ├── interface27.go
│ ├── interface28.go
│ ├── interface29.go
│ ├── interface3.go
│ ├── interface30.go
│ ├── interface31.go
│ ├── interface32.go
│ ├── interface33.go
│ ├── interface34.go
│ ├── interface35.go
│ ├── interface36.go
│ ├── interface37.go
│ ├── interface38.go
│ ├── interface39.go
│ ├── interface4.go
│ ├── interface40.go
│ ├── interface41.go
│ ├── interface42.go
│ ├── interface43.go
│ ├── interface44.go
│ ├── interface45.go
│ ├── interface46.go
│ ├── interface47.go
│ ├── interface48.go
│ ├── interface49.go
│ ├── interface5.go
│ ├── interface50.go
│ ├── interface51.go
│ ├── interface52.go
│ ├── interface6.go
│ ├── interface7.go
│ ├── interface8.go
│ ├── interface9.go
│ ├── interp.gi
│ ├── interp2.gi
│ ├── io0.go
│ ├── io1.go
│ ├── io2.go
│ ├── iota.go
│ ├── iota0.go
│ ├── ipp_as_key.go
│ ├── issue-1007.go
│ ├── issue-1010.go
│ ├── issue-1022.go
│ ├── issue-1052.go
│ ├── issue-1065.go
│ ├── issue-1068.go
│ ├── issue-1088.go
│ ├── issue-1089.go
│ ├── issue-1093.go
│ ├── issue-1094.go
│ ├── issue-1101.go
│ ├── issue-1115.go
│ ├── issue-1126.go
│ ├── issue-1128.go
│ ├── issue-1134.go
│ ├── issue-1136.go
│ ├── issue-1145.go
│ ├── issue-1156.go
│ ├── issue-1163.go
│ ├── issue-1166.go
│ ├── issue-1167.go
│ ├── issue-1173.go
│ ├── issue-1175.go
│ ├── issue-1177.go
│ ├── issue-1179.go
│ ├── issue-1181.go
│ ├── issue-1185.go
│ ├── issue-1187.go
│ ├── issue-1189.go
│ ├── issue-1202.go
│ ├── issue-1205.go
│ ├── issue-1208.go
│ ├── issue-1260.go
│ ├── issue-1276.go
│ ├── issue-1280.go
│ ├── issue-1285.go
│ ├── issue-1288.go
│ ├── issue-1300.go
│ ├── issue-1304.go
│ ├── issue-1306.go
│ ├── issue-1308.go
│ ├── issue-1311.go
│ ├── issue-1315.go
│ ├── issue-1320.go
│ ├── issue-1326.go
│ ├── issue-1328.go
│ ├── issue-1330.go
│ ├── issue-1332.go
│ ├── issue-1333.go
│ ├── issue-1337.go
│ ├── issue-1342.go
│ ├── issue-1344.go
│ ├── issue-1354.go
│ ├── issue-1355.go
│ ├── issue-1360.go
│ ├── issue-1361.go
│ ├── issue-1364.go
│ ├── issue-1365.go
│ ├── issue-1368.go
│ ├── issue-1371.go
│ ├── issue-1373.go
│ ├── issue-1375.go
│ ├── issue-1378.go
│ ├── issue-1381.go
│ ├── issue-1404.go
│ ├── issue-1408.go
│ ├── issue-1411.go
│ ├── issue-1416.go
│ ├── issue-1421.go
│ ├── issue-1425.go
│ ├── issue-1439.go
│ ├── issue-1442.go
│ ├── issue-1447.go
│ ├── issue-1451.go
│ ├── issue-1454.go
│ ├── issue-1459.go
│ ├── issue-1460.go
│ ├── issue-1465.go
│ ├── issue-1466.go
│ ├── issue-1470.go
│ ├── issue-1475.go
│ ├── issue-1488.go
│ ├── issue-1496.go
│ ├── issue-1515.go
│ ├── issue-1536.go
│ ├── issue-1571.go
│ ├── issue-1594.go
│ ├── issue-1618.go
│ ├── issue-1640.go
│ ├── issue-1653.go
│ ├── issue-435.go
│ ├── issue-558.go
│ ├── issue-735.go
│ ├── issue-770.go
│ ├── issue-772.go
│ ├── issue-775.go
│ ├── issue-776.go
│ ├── issue-782.go
│ ├── issue-784.go
│ ├── issue-880.go
│ ├── issue-981.go
│ ├── issue-993.go
│ ├── l2.go
│ ├── l3.go
│ ├── l4.go
│ ├── l5.go
│ ├── len0.go
│ ├── m1/
│ │ ├── main.go
│ │ └── main_test.go
│ ├── m2/
│ │ └── m2_test.go
│ ├── make.go
│ ├── make0.go
│ ├── make1.go
│ ├── make2.go
│ ├── map.go
│ ├── map10.go
│ ├── map11.go
│ ├── map12.go
│ ├── map13.go
│ ├── map14.go
│ ├── map15.go
│ ├── map16.go
│ ├── map17.go
│ ├── map18.go
│ ├── map19.go
│ ├── map2.go
│ ├── map20.go
│ ├── map21.go
│ ├── map22.go
│ ├── map23.go
│ ├── map24.go
│ ├── map25.go
│ ├── map26.go
│ ├── map27.go
│ ├── map28.go
│ ├── map29.go
│ ├── map3.go
│ ├── map30.go
│ ├── map31.go
│ ├── map4.go
│ ├── map5.go
│ ├── map6.go
│ ├── map7.go
│ ├── map8.go
│ ├── map9.go
│ ├── math0.go
│ ├── math1.go
│ ├── math2.go
│ ├── math3.go
│ ├── method.go
│ ├── method0.go
│ ├── method1.go
│ ├── method10.go
│ ├── method11.go
│ ├── method12.go
│ ├── method13.go
│ ├── method14.go
│ ├── method15.go
│ ├── method16.go
│ ├── method17.go
│ ├── method18.go
│ ├── method19.go
│ ├── method2.go
│ ├── method20.go
│ ├── method21.go
│ ├── method22.go
│ ├── method23.go
│ ├── method24.go
│ ├── method25.go
│ ├── method26.go
│ ├── method27.go
│ ├── method28.go
│ ├── method29.go
│ ├── method3.go
│ ├── method30.go
│ ├── method31.go
│ ├── method32.go
│ ├── method33.go
│ ├── method34.go
│ ├── method35.go
│ ├── method36.go
│ ├── method37.go
│ ├── method38/
│ │ ├── a.go
│ │ └── b.go
│ ├── method38.go
│ ├── method39.go
│ ├── method4.go
│ ├── method40.go
│ ├── method5.go
│ ├── method6.go
│ ├── method7.go
│ ├── method8.go
│ ├── method9.go
│ ├── named0.go
│ ├── named1.go
│ ├── named2.go
│ ├── named3/
│ │ └── named3.go
│ ├── named3.go
│ ├── named4.go
│ ├── neg0.go
│ ├── new0.go
│ ├── new1.go
│ ├── new2.go
│ ├── nil0.go
│ ├── nil1.go
│ ├── nil2.go
│ ├── nil3.go
│ ├── not0.go
│ ├── not1.go
│ ├── not2.go
│ ├── num0.go
│ ├── op0.go
│ ├── op1.go
│ ├── op10.go
│ ├── op11.go
│ ├── op2.go
│ ├── op3.go
│ ├── op4.go
│ ├── op5.go
│ ├── op6.go
│ ├── op7.go
│ ├── op8.go
│ ├── op9.go
│ ├── opfloat32.go
│ ├── opfloat64.go
│ ├── opint16.go
│ ├── opint32.go
│ ├── opint64.go
│ ├── opint8.go
│ ├── opstring.go
│ ├── opuint16.go
│ ├── opuint32.go
│ ├── opuint64.go
│ ├── opuint8.go
│ ├── or0.go
│ ├── or1.go
│ ├── or2.go
│ ├── os0.go
│ ├── p1/
│ │ ├── s1.go
│ │ └── s2.go
│ ├── p2/
│ │ └── p2.go
│ ├── p3/
│ │ └── empty
│ ├── p4/
│ │ └── p4.go
│ ├── p5/
│ │ └── p5.go
│ ├── p5.go
│ ├── p6/
│ │ └── p6.go
│ ├── p6.go
│ ├── panic0.go
│ ├── pkgname0.go
│ ├── pkgname1.go
│ ├── pkgname2.go
│ ├── primes.go
│ ├── print0.go
│ ├── ptr0.go
│ ├── ptr1.go
│ ├── ptr2.go
│ ├── ptr3.go
│ ├── ptr4.go
│ ├── ptr5.go
│ ├── ptr5a.go
│ ├── ptr6.go
│ ├── ptr7.go
│ ├── ptr8.go
│ ├── ptr_array0.go
│ ├── ptr_array1.go
│ ├── ptr_array2.go
│ ├── ptr_array3.go
│ ├── range0.go
│ ├── range1.go
│ ├── range2.go
│ ├── range3.go
│ ├── range4.go
│ ├── range5.go
│ ├── range6.go
│ ├── range7.go
│ ├── range8.go
│ ├── range9.go
│ ├── real0.go
│ ├── recover0.go
│ ├── recover1.go
│ ├── recover2.go
│ ├── recover3.go
│ ├── recover4.go
│ ├── recurse0.go
│ ├── recurse1.go
│ ├── recurse2.go
│ ├── recurse3.go
│ ├── redeclaration-global0.go
│ ├── redeclaration-global1.go
│ ├── redeclaration-global2.go
│ ├── redeclaration-global3.go
│ ├── redeclaration-global4.go
│ ├── redeclaration-global5.go
│ ├── redeclaration-global6.go
│ ├── redeclaration-global7.go
│ ├── redeclaration0.go
│ ├── redeclaration1.go
│ ├── redeclaration2.go
│ ├── redeclaration3.go
│ ├── redeclaration4.go
│ ├── redeclaration5.go
│ ├── restricted0.go
│ ├── restricted1.go
│ ├── restricted2.go
│ ├── restricted3.go
│ ├── ret1.go
│ ├── ret2.go
│ ├── ret3.go
│ ├── ret4.go
│ ├── ret5.go
│ ├── ret6.go
│ ├── ret7.go
│ ├── ret8.go
│ ├── run0.go
│ ├── run1.go
│ ├── run10.go
│ ├── run11.go
│ ├── run12.go
│ ├── run13.go
│ ├── run4.go
│ ├── run5.go
│ ├── run6.go
│ ├── run7.go
│ ├── run8.go
│ ├── run9.go
│ ├── rune0.go
│ ├── rune1.go
│ ├── rune2.go
│ ├── sample.plugin
│ ├── scope0.go
│ ├── scope1.go
│ ├── scope2.go
│ ├── scope3.go
│ ├── scope4.go
│ ├── scope5.go
│ ├── scope6.go
│ ├── scope7.go
│ ├── secure.gi
│ ├── select.go
│ ├── select0.go
│ ├── select1.go
│ ├── select10.go
│ ├── select11.go
│ ├── select12.go
│ ├── select13.go
│ ├── select14.go
│ ├── select15.go
│ ├── select2.go
│ ├── select3.go
│ ├── select4.go
│ ├── select5.go
│ ├── select6.go
│ ├── select7.go
│ ├── select8.go
│ ├── select9.go
│ ├── selector-scope0.go
│ ├── server.go
│ ├── server0.go
│ ├── server1.go
│ ├── server1a.go
│ ├── server2.go
│ ├── server3.go
│ ├── server4.go
│ ├── server5.go
│ ├── server6.go
│ ├── server7.go
│ ├── shift0.go
│ ├── shift1.go
│ ├── shift2.go
│ ├── shift3.go
│ ├── sieve.go
│ ├── slice.go
│ ├── str.go
│ ├── str0.go
│ ├── str1.go
│ ├── str2.go
│ ├── str3.go
│ ├── str4.go
│ ├── struct.go
│ ├── struct0.go
│ ├── struct0a.go
│ ├── struct1.go
│ ├── struct10.go
│ ├── struct11.go
│ ├── struct12.go
│ ├── struct13.go
│ ├── struct14.go
│ ├── struct15.go
│ ├── struct16.go
│ ├── struct17.go
│ ├── struct18.go
│ ├── struct19.go
│ ├── struct2.go
│ ├── struct20.go
│ ├── struct21.go
│ ├── struct22.go
│ ├── struct23.go
│ ├── struct24.go
│ ├── struct25.go
│ ├── struct26.go
│ ├── struct27.go
│ ├── struct28.go
│ ├── struct29.go
│ ├── struct3.go
│ ├── struct30.go
│ ├── struct31.go
│ ├── struct32.go
│ ├── struct33.go
│ ├── struct34.go
│ ├── struct35.go
│ ├── struct36.go
│ ├── struct37.go
│ ├── struct38.go
│ ├── struct39.go
│ ├── struct4.go
│ ├── struct40.go
│ ├── struct41.go
│ ├── struct42.go
│ ├── struct43.go
│ ├── struct44.go
│ ├── struct45.go
│ ├── struct46.go
│ ├── struct47.go
│ ├── struct48.go
│ ├── struct49.go
│ ├── struct5.go
│ ├── struct50.go
│ ├── struct51.go
│ ├── struct52.go
│ ├── struct53.go
│ ├── struct54.go
│ ├── struct55.go
│ ├── struct56.go
│ ├── struct57.go
│ ├── struct58.go
│ ├── struct59.go
│ ├── struct6.go
│ ├── struct60.go
│ ├── struct61.go
│ ├── struct62.go
│ ├── struct7.go
│ ├── struct8.go
│ ├── struct9.go
│ ├── switch.go
│ ├── switch0.go
│ ├── switch1.go
│ ├── switch10.go
│ ├── switch11.go
│ ├── switch12.go
│ ├── switch13.go
│ ├── switch14.go
│ ├── switch15.go
│ ├── switch16.go
│ ├── switch17.go
│ ├── switch18.go
│ ├── switch19.go
│ ├── switch2.go
│ ├── switch20.go
│ ├── switch21.go
│ ├── switch22.go
│ ├── switch23.go
│ ├── switch24.go
│ ├── switch25.go
│ ├── switch26.go
│ ├── switch27.go
│ ├── switch28.go
│ ├── switch29.go
│ ├── switch3.go
│ ├── switch30.go
│ ├── switch31.go
│ ├── switch32.go
│ ├── switch33.go
│ ├── switch34.go
│ ├── switch35.go
│ ├── switch36.go
│ ├── switch37.go
│ ├── switch38.go
│ ├── switch39.go
│ ├── switch4.go
│ ├── switch40.go
│ ├── switch5.go
│ ├── switch6.go
│ ├── switch7.go
│ ├── switch8.go
│ ├── switch9.go
│ ├── tag0.go
│ ├── testdata/
│ │ └── redeclaration-global7/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── quux.go
│ │ ├── baz/
│ │ │ └── quux.go
│ │ ├── tata/
│ │ │ └── tutu.go
│ │ └── toto/
│ │ └── titi.go
│ ├── time0.go
│ ├── time1.go
│ ├── time10.go
│ ├── time11.go
│ ├── time12.go
│ ├── time13.go
│ ├── time14.go
│ ├── time15.go
│ ├── time16.go
│ ├── time2.go
│ ├── time3.go
│ ├── time4.go
│ ├── time5.go
│ ├── time6.go
│ ├── time7.go
│ ├── time8.go
│ ├── time9.go
│ ├── type0.go
│ ├── type1.go
│ ├── type10.go
│ ├── type11.go
│ ├── type12.go
│ ├── type13.go
│ ├── type14.go
│ ├── type15.go
│ ├── type16.go
│ ├── type17.go
│ ├── type18.go
│ ├── type19.go
│ ├── type2.go
│ ├── type20.go
│ ├── type21.go
│ ├── type22.go
│ ├── type23.go
│ ├── type24.go
│ ├── type25.go
│ ├── type26.go
│ ├── type27.go
│ ├── type28.go
│ ├── type29.go
│ ├── type3.go
│ ├── type30.go
│ ├── type31.go
│ ├── type32.go
│ ├── type33.go
│ ├── type34.go
│ ├── type4.go
│ ├── type5.go
│ ├── type6.go
│ ├── type7.go
│ ├── type8.go
│ ├── type9.go
│ ├── unsafe0.go
│ ├── unsafe1.go
│ ├── unsafe10.go
│ ├── unsafe2.go
│ ├── unsafe3.go
│ ├── unsafe4.go
│ ├── unsafe5.go
│ ├── unsafe6.go
│ ├── unsafe7.go
│ ├── unsafe8.go
│ ├── var.go
│ ├── var10.go
│ ├── var11.go
│ ├── var12.go
│ ├── var13.go
│ ├── var14.go
│ ├── var15.go
│ ├── var16.go
│ ├── var2.go
│ ├── var3.go
│ ├── var4.go
│ ├── var5.go
│ ├── var6.go
│ ├── var7.go
│ ├── var8.go
│ ├── var9.go
│ ├── variadic.go
│ ├── variadic0.go
│ ├── variadic1.go
│ ├── variadic10.go
│ ├── variadic2.go
│ ├── variadic3.go
│ ├── variadic4.go
│ ├── variadic5.go
│ ├── variadic6.go
│ ├── variadic7.go
│ ├── variadic8.go
│ ├── variadic9.go
│ └── vars/
│ ├── first.go
│ └── second.go
├── cmd/
│ └── yaegi/
│ ├── extract.go
│ ├── help.go
│ ├── run.go
│ ├── test.go
│ ├── yaegi.go
│ └── yaegi_test.go
├── example/
│ ├── closure/
│ │ ├── _pkg/
│ │ │ └── src/
│ │ │ └── foo/
│ │ │ └── bar/
│ │ │ └── bar.go
│ │ └── closure_test.go
│ ├── fs/
│ │ └── fs_test.go
│ ├── getfunc/
│ │ ├── _gopath/
│ │ │ └── src/
│ │ │ └── github.com/
│ │ │ └── foo/
│ │ │ └── bar/
│ │ │ └── foobar.go
│ │ └── getfunc_test.go
│ └── pkg/
│ ├── _pkg/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ └── fromage.go
│ ├── _pkg0/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ ├── cheese/
│ │ │ │ └── cheese.go
│ │ │ └── fromage.go
│ │ └── pkg.go
│ ├── _pkg1/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ └── pkg.go
│ ├── _pkg10/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ └── fromage.go
│ ├── _pkg11/
│ │ └── src/
│ │ └── foo/
│ │ ├── foo.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ └── fromage.go
│ ├── _pkg12/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── foo/
│ │ ├── main.go
│ │ ├── pkg/
│ │ │ └── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── bar/
│ │ └── bar.go
│ ├── _pkg13/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── foo/
│ │ └── bar/
│ │ ├── main.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── bat/
│ │ └── baz/
│ │ └── baz.go
│ ├── _pkg2/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ ├── fromage.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ └── fromage.go
│ ├── _pkg3/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ ├── couteau/
│ │ │ └── couteau.go
│ │ ├── fromage.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ └── fromage.go
│ ├── _pkg4/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── fromage/
│ │ ├── couteau/
│ │ │ └── couteau.go
│ │ ├── fromage.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ ├── cheese.go
│ │ └── vin/
│ │ └── vin.go
│ ├── _pkg5/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ ├── cheese/
│ │ │ ├── cheese.go
│ │ │ └── vin/
│ │ │ └── vin.go
│ │ └── fromage/
│ │ ├── couteau/
│ │ │ └── couteau.go
│ │ └── fromage.go
│ ├── _pkg6/
│ │ └── src/
│ │ ├── github.com/
│ │ │ └── foo/
│ │ │ └── pkg/
│ │ │ ├── pkg.go
│ │ │ └── vendor/
│ │ │ └── guthib.com/
│ │ │ └── traefik/
│ │ │ └── fromage/
│ │ │ ├── couteau/
│ │ │ │ └── couteau.go
│ │ │ └── fromage.go
│ │ └── guthib.com/
│ │ └── traefik/
│ │ └── cheese/
│ │ ├── cheese.go
│ │ └── vin/
│ │ └── vin.go
│ ├── _pkg7/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── pkg.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── traefik/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ └── vin/
│ │ ├── vendor/
│ │ │ └── guthib.com/
│ │ │ └── traefik/
│ │ │ └── cheese/
│ │ │ └── cheese.go
│ │ └── vin.go
│ ├── _pkg8/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ └── pkg.go
│ ├── _pkg9/
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ └── pkg/
│ │ ├── fromage/
│ │ │ └── fromage.go
│ │ ├── pkg.go
│ │ └── pkgfalse.go
│ └── pkg_test.go
├── extract/
│ ├── extract.go
│ ├── extract_test.go
│ └── testdata/
│ ├── 1/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz/
│ │ ├── baz.go
│ │ └── go.mod
│ ├── 2/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz/
│ │ └── baz.go
│ ├── 3/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz/
│ │ ├── baz.go
│ │ └── go.mod
│ ├── 4/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── bar/
│ │ ├── main.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── baz/
│ │ ├── baz.go
│ │ └── go.mod
│ ├── 5/
│ │ └── src/
│ │ └── guthib.com/
│ │ └── bar/
│ │ ├── main.go
│ │ └── vendor/
│ │ └── guthib.com/
│ │ └── baz/
│ │ └── baz.go
│ ├── 6/
│ │ └── src/
│ │ └── guthib.com/
│ │ ├── bar/
│ │ │ └── main.go
│ │ └── baz-baz/
│ │ ├── baz.go
│ │ └── go.mod
│ └── 7/
│ └── src/
│ └── guthib.com/
│ └── variadic/
│ ├── go.mod
│ └── variadic.go
├── generate.go
├── go.mod
├── install.sh
├── internal/
│ ├── cmd/
│ │ ├── extract/
│ │ │ └── extract.go
│ │ └── genop/
│ │ └── genop.go
│ └── unsafe2/
│ ├── go1_20_unsafe.go
│ ├── go1_21_unsafe.go
│ └── unsafe_test.go
├── interp/
│ ├── ast.go
│ ├── build.go
│ ├── build_test.go
│ ├── cfg.go
│ ├── compile_test.go
│ ├── debugger.go
│ ├── doc.go
│ ├── dot.go
│ ├── example_eval_test.go
│ ├── export_test.go
│ ├── generic.go
│ ├── gta.go
│ ├── hooks.go
│ ├── interp.go
│ ├── interp_chan_test.go
│ ├── interp_consistent_test.go
│ ├── interp_eval_test.go
│ ├── interp_export_test.go
│ ├── interp_file_test.go
│ ├── interp_issue_1634_test.go
│ ├── interp_test.go
│ ├── op.go
│ ├── program.go
│ ├── realfs.go
│ ├── run.go
│ ├── scope.go
│ ├── self_example_test.go
│ ├── src.go
│ ├── src_test.go
│ ├── testdata/
│ │ ├── concurrent/
│ │ │ ├── composite/
│ │ │ │ ├── composite_lit.go
│ │ │ │ └── composite_sparse.go
│ │ │ ├── hello1.go
│ │ │ └── hello2.go
│ │ ├── multi/
│ │ │ └── 731/
│ │ │ ├── sample1.go
│ │ │ ├── sample2.go
│ │ │ └── sample3.go
│ │ └── src/
│ │ └── github.com/
│ │ └── foo/
│ │ ├── bar/
│ │ │ └── baz/
│ │ │ └── baz.go
│ │ └── vendor/
│ │ └── whatever/
│ │ └── whatever.go
│ ├── trace.go
│ ├── type.go
│ ├── typecheck.go
│ ├── typestring.go
│ ├── use.go
│ └── value.go
└── stdlib/
├── generic/
│ ├── go1_21_cmp.go.txt
│ ├── go1_21_generic.go
│ ├── go1_21_maps.go.txt
│ ├── go1_21_slices.go.txt
│ ├── go1_21_sync.go.txt
│ ├── go1_21_sync_atomic.go.txt
│ ├── go1_22_cmp_cmp.go.txt
│ ├── go1_22_generic.go
│ ├── go1_22_maps_maps.go.txt
│ ├── go1_22_slices_slices.go.txt
│ ├── go1_22_slices_sort.go.txt
│ ├── go1_22_slices_zsortanyfunc.go.txt
│ ├── go1_22_sync_atomic_type.go.txt
│ └── go1_22_sync_oncefunc.go.txt
├── go1_21_archive_tar.go
├── go1_21_archive_zip.go
├── go1_21_bufio.go
├── go1_21_bytes.go
├── go1_21_cmp.go
├── go1_21_compress_bzip2.go
├── go1_21_compress_flate.go
├── go1_21_compress_gzip.go
├── go1_21_compress_lzw.go
├── go1_21_compress_zlib.go
├── go1_21_container_heap.go
├── go1_21_container_list.go
├── go1_21_container_ring.go
├── go1_21_context.go
├── go1_21_crypto.go
├── go1_21_crypto_aes.go
├── go1_21_crypto_cipher.go
├── go1_21_crypto_des.go
├── go1_21_crypto_dsa.go
├── go1_21_crypto_ecdh.go
├── go1_21_crypto_ecdsa.go
├── go1_21_crypto_ed25519.go
├── go1_21_crypto_elliptic.go
├── go1_21_crypto_hmac.go
├── go1_21_crypto_md5.go
├── go1_21_crypto_rand.go
├── go1_21_crypto_rc4.go
├── go1_21_crypto_rsa.go
├── go1_21_crypto_sha1.go
├── go1_21_crypto_sha256.go
├── go1_21_crypto_sha512.go
├── go1_21_crypto_subtle.go
├── go1_21_crypto_tls.go
├── go1_21_crypto_x509.go
├── go1_21_crypto_x509_pkix.go
├── go1_21_database_sql.go
├── go1_21_database_sql_driver.go
├── go1_21_debug_buildinfo.go
├── go1_21_debug_dwarf.go
├── go1_21_debug_elf.go
├── go1_21_debug_gosym.go
├── go1_21_debug_macho.go
├── go1_21_debug_pe.go
├── go1_21_debug_plan9obj.go
├── go1_21_encoding.go
├── go1_21_encoding_ascii85.go
├── go1_21_encoding_asn1.go
├── go1_21_encoding_base32.go
├── go1_21_encoding_base64.go
├── go1_21_encoding_binary.go
├── go1_21_encoding_csv.go
├── go1_21_encoding_gob.go
├── go1_21_encoding_hex.go
├── go1_21_encoding_json.go
├── go1_21_encoding_pem.go
├── go1_21_encoding_xml.go
├── go1_21_errors.go
├── go1_21_expvar.go
├── go1_21_flag.go
├── go1_21_fmt.go
├── go1_21_go_ast.go
├── go1_21_go_build.go
├── go1_21_go_build_constraint.go
├── go1_21_go_constant.go
├── go1_21_go_doc.go
├── go1_21_go_doc_comment.go
├── go1_21_go_format.go
├── go1_21_go_importer.go
├── go1_21_go_parser.go
├── go1_21_go_printer.go
├── go1_21_go_scanner.go
├── go1_21_go_token.go
├── go1_21_go_types.go
├── go1_21_hash.go
├── go1_21_hash_adler32.go
├── go1_21_hash_crc32.go
├── go1_21_hash_crc64.go
├── go1_21_hash_fnv.go
├── go1_21_hash_maphash.go
├── go1_21_html.go
├── go1_21_html_template.go
├── go1_21_image.go
├── go1_21_image_color.go
├── go1_21_image_color_palette.go
├── go1_21_image_draw.go
├── go1_21_image_gif.go
├── go1_21_image_jpeg.go
├── go1_21_image_png.go
├── go1_21_index_suffixarray.go
├── go1_21_io.go
├── go1_21_io_fs.go
├── go1_21_io_ioutil.go
├── go1_21_log.go
├── go1_21_log_slog.go
├── go1_21_log_syslog.go
├── go1_21_maps.go
├── go1_21_math.go
├── go1_21_math_big.go
├── go1_21_math_bits.go
├── go1_21_math_cmplx.go
├── go1_21_math_rand.go
├── go1_21_mime.go
├── go1_21_mime_multipart.go
├── go1_21_mime_quotedprintable.go
├── go1_21_net.go
├── go1_21_net_http.go
├── go1_21_net_http_cgi.go
├── go1_21_net_http_cookiejar.go
├── go1_21_net_http_fcgi.go
├── go1_21_net_http_httptest.go
├── go1_21_net_http_httptrace.go
├── go1_21_net_http_httputil.go
├── go1_21_net_http_pprof.go
├── go1_21_net_mail.go
├── go1_21_net_netip.go
├── go1_21_net_rpc.go
├── go1_21_net_rpc_jsonrpc.go
├── go1_21_net_smtp.go
├── go1_21_net_textproto.go
├── go1_21_net_url.go
├── go1_21_os.go
├── go1_21_os_signal.go
├── go1_21_os_user.go
├── go1_21_path.go
├── go1_21_path_filepath.go
├── go1_21_reflect.go
├── go1_21_regexp.go
├── go1_21_regexp_syntax.go
├── go1_21_runtime.go
├── go1_21_runtime_debug.go
├── go1_21_runtime_metrics.go
├── go1_21_runtime_pprof.go
├── go1_21_runtime_trace.go
├── go1_21_slices.go
├── go1_21_sort.go
├── go1_21_strconv.go
├── go1_21_strings.go
├── go1_21_sync.go
├── go1_21_sync_atomic.go
├── go1_21_testing.go
├── go1_21_testing_fstest.go
├── go1_21_testing_iotest.go
├── go1_21_testing_quick.go
├── go1_21_testing_slogtest.go
├── go1_21_text_scanner.go
├── go1_21_text_tabwriter.go
├── go1_21_text_template.go
├── go1_21_text_template_parse.go
├── go1_21_time.go
├── go1_21_unicode.go
├── go1_21_unicode_utf16.go
├── go1_21_unicode_utf8.go
├── go1_22_archive_tar.go
├── go1_22_archive_zip.go
├── go1_22_bufio.go
├── go1_22_bytes.go
├── go1_22_cmp.go
├── go1_22_compress_bzip2.go
├── go1_22_compress_flate.go
├── go1_22_compress_gzip.go
├── go1_22_compress_lzw.go
├── go1_22_compress_zlib.go
├── go1_22_container_heap.go
├── go1_22_container_list.go
├── go1_22_container_ring.go
├── go1_22_context.go
├── go1_22_crypto.go
├── go1_22_crypto_aes.go
├── go1_22_crypto_cipher.go
├── go1_22_crypto_des.go
├── go1_22_crypto_dsa.go
├── go1_22_crypto_ecdh.go
├── go1_22_crypto_ecdsa.go
├── go1_22_crypto_ed25519.go
├── go1_22_crypto_elliptic.go
├── go1_22_crypto_hmac.go
├── go1_22_crypto_md5.go
├── go1_22_crypto_rand.go
├── go1_22_crypto_rc4.go
├── go1_22_crypto_rsa.go
├── go1_22_crypto_sha1.go
├── go1_22_crypto_sha256.go
├── go1_22_crypto_sha512.go
├── go1_22_crypto_subtle.go
├── go1_22_crypto_tls.go
├── go1_22_crypto_x509.go
├── go1_22_crypto_x509_pkix.go
├── go1_22_database_sql.go
├── go1_22_database_sql_driver.go
├── go1_22_debug_buildinfo.go
├── go1_22_debug_dwarf.go
├── go1_22_debug_elf.go
├── go1_22_debug_gosym.go
├── go1_22_debug_macho.go
├── go1_22_debug_pe.go
├── go1_22_debug_plan9obj.go
├── go1_22_encoding.go
├── go1_22_encoding_ascii85.go
├── go1_22_encoding_asn1.go
├── go1_22_encoding_base32.go
├── go1_22_encoding_base64.go
├── go1_22_encoding_binary.go
├── go1_22_encoding_csv.go
├── go1_22_encoding_gob.go
├── go1_22_encoding_hex.go
├── go1_22_encoding_json.go
├── go1_22_encoding_pem.go
├── go1_22_encoding_xml.go
├── go1_22_errors.go
├── go1_22_expvar.go
├── go1_22_flag.go
├── go1_22_fmt.go
├── go1_22_go_ast.go
├── go1_22_go_build.go
├── go1_22_go_build_constraint.go
├── go1_22_go_constant.go
├── go1_22_go_doc.go
├── go1_22_go_doc_comment.go
├── go1_22_go_format.go
├── go1_22_go_importer.go
├── go1_22_go_parser.go
├── go1_22_go_printer.go
├── go1_22_go_scanner.go
├── go1_22_go_token.go
├── go1_22_go_types.go
├── go1_22_go_version.go
├── go1_22_hash.go
├── go1_22_hash_adler32.go
├── go1_22_hash_crc32.go
├── go1_22_hash_crc64.go
├── go1_22_hash_fnv.go
├── go1_22_hash_maphash.go
├── go1_22_html.go
├── go1_22_html_template.go
├── go1_22_image.go
├── go1_22_image_color.go
├── go1_22_image_color_palette.go
├── go1_22_image_draw.go
├── go1_22_image_gif.go
├── go1_22_image_jpeg.go
├── go1_22_image_png.go
├── go1_22_index_suffixarray.go
├── go1_22_io.go
├── go1_22_io_fs.go
├── go1_22_io_ioutil.go
├── go1_22_log.go
├── go1_22_log_slog.go
├── go1_22_log_syslog.go
├── go1_22_maps.go
├── go1_22_math.go
├── go1_22_math_big.go
├── go1_22_math_bits.go
├── go1_22_math_cmplx.go
├── go1_22_math_rand.go
├── go1_22_math_rand_v2.go
├── go1_22_mime.go
├── go1_22_mime_multipart.go
├── go1_22_mime_quotedprintable.go
├── go1_22_net.go
├── go1_22_net_http.go
├── go1_22_net_http_cgi.go
├── go1_22_net_http_cookiejar.go
├── go1_22_net_http_fcgi.go
├── go1_22_net_http_httptest.go
├── go1_22_net_http_httptrace.go
├── go1_22_net_http_httputil.go
├── go1_22_net_http_pprof.go
├── go1_22_net_mail.go
├── go1_22_net_netip.go
├── go1_22_net_rpc.go
├── go1_22_net_rpc_jsonrpc.go
├── go1_22_net_smtp.go
├── go1_22_net_textproto.go
├── go1_22_net_url.go
├── go1_22_os.go
├── go1_22_os_signal.go
├── go1_22_os_user.go
├── go1_22_path.go
├── go1_22_path_filepath.go
├── go1_22_reflect.go
├── go1_22_regexp.go
├── go1_22_regexp_syntax.go
├── go1_22_runtime.go
├── go1_22_runtime_debug.go
├── go1_22_runtime_metrics.go
├── go1_22_runtime_pprof.go
├── go1_22_runtime_trace.go
├── go1_22_slices.go
├── go1_22_sort.go
├── go1_22_strconv.go
├── go1_22_strings.go
├── go1_22_sync.go
├── go1_22_sync_atomic.go
├── go1_22_testing.go
├── go1_22_testing_fstest.go
├── go1_22_testing_iotest.go
├── go1_22_testing_quick.go
├── go1_22_testing_slogtest.go
├── go1_22_text_scanner.go
├── go1_22_text_tabwriter.go
├── go1_22_text_template.go
├── go1_22_text_template_parse.go
├── go1_22_time.go
├── go1_22_unicode.go
├── go1_22_unicode_utf16.go
├── go1_22_unicode_utf8.go
├── maptypes.go
├── restricted.go
├── stdlib-go1.22.go
├── stdlib.go
├── syscall/
│ ├── go1_21_syscall_aix_ppc64.go
│ ├── go1_21_syscall_android_386.go
│ ├── go1_21_syscall_android_amd64.go
│ ├── go1_21_syscall_android_arm.go
│ ├── go1_21_syscall_android_arm64.go
│ ├── go1_21_syscall_darwin_amd64.go
│ ├── go1_21_syscall_darwin_arm64.go
│ ├── go1_21_syscall_dragonfly_amd64.go
│ ├── go1_21_syscall_freebsd_386.go
│ ├── go1_21_syscall_freebsd_amd64.go
│ ├── go1_21_syscall_freebsd_arm.go
│ ├── go1_21_syscall_freebsd_arm64.go
│ ├── go1_21_syscall_freebsd_riscv64.go
│ ├── go1_21_syscall_illumos_amd64.go
│ ├── go1_21_syscall_ios_amd64.go
│ ├── go1_21_syscall_ios_arm64.go
│ ├── go1_21_syscall_js_wasm.go
│ ├── go1_21_syscall_linux_386.go
│ ├── go1_21_syscall_linux_amd64.go
│ ├── go1_21_syscall_linux_arm.go
│ ├── go1_21_syscall_linux_arm64.go
│ ├── go1_21_syscall_linux_loong64.go
│ ├── go1_21_syscall_linux_mips.go
│ ├── go1_21_syscall_linux_mips64.go
│ ├── go1_21_syscall_linux_mips64le.go
│ ├── go1_21_syscall_linux_mipsle.go
│ ├── go1_21_syscall_linux_ppc64.go
│ ├── go1_21_syscall_linux_ppc64le.go
│ ├── go1_21_syscall_linux_riscv64.go
│ ├── go1_21_syscall_linux_s390x.go
│ ├── go1_21_syscall_netbsd_386.go
│ ├── go1_21_syscall_netbsd_amd64.go
│ ├── go1_21_syscall_netbsd_arm.go
│ ├── go1_21_syscall_netbsd_arm64.go
│ ├── go1_21_syscall_openbsd_386.go
│ ├── go1_21_syscall_openbsd_amd64.go
│ ├── go1_21_syscall_openbsd_arm.go
│ ├── go1_21_syscall_openbsd_arm64.go
│ ├── go1_21_syscall_plan9_386.go
│ ├── go1_21_syscall_plan9_amd64.go
│ ├── go1_21_syscall_plan9_arm.go
│ ├── go1_21_syscall_solaris_amd64.go
│ ├── go1_21_syscall_wasip1_wasm.go
│ ├── go1_21_syscall_windows_386.go
│ ├── go1_21_syscall_windows_amd64.go
│ ├── go1_21_syscall_windows_arm.go
│ ├── go1_21_syscall_windows_arm64.go
│ ├── go1_22_syscall_aix_ppc64.go
│ ├── go1_22_syscall_android_386.go
│ ├── go1_22_syscall_android_amd64.go
│ ├── go1_22_syscall_android_arm.go
│ ├── go1_22_syscall_android_arm64.go
│ ├── go1_22_syscall_darwin_amd64.go
│ ├── go1_22_syscall_darwin_arm64.go
│ ├── go1_22_syscall_dragonfly_amd64.go
│ ├── go1_22_syscall_freebsd_386.go
│ ├── go1_22_syscall_freebsd_amd64.go
│ ├── go1_22_syscall_freebsd_arm.go
│ ├── go1_22_syscall_freebsd_arm64.go
│ ├── go1_22_syscall_freebsd_riscv64.go
│ ├── go1_22_syscall_illumos_amd64.go
│ ├── go1_22_syscall_ios_amd64.go
│ ├── go1_22_syscall_ios_arm64.go
│ ├── go1_22_syscall_js_wasm.go
│ ├── go1_22_syscall_linux_386.go
│ ├── go1_22_syscall_linux_amd64.go
│ ├── go1_22_syscall_linux_arm.go
│ ├── go1_22_syscall_linux_arm64.go
│ ├── go1_22_syscall_linux_loong64.go
│ ├── go1_22_syscall_linux_mips.go
│ ├── go1_22_syscall_linux_mips64.go
│ ├── go1_22_syscall_linux_mips64le.go
│ ├── go1_22_syscall_linux_mipsle.go
│ ├── go1_22_syscall_linux_ppc64.go
│ ├── go1_22_syscall_linux_ppc64le.go
│ ├── go1_22_syscall_linux_riscv64.go
│ ├── go1_22_syscall_linux_s390x.go
│ ├── go1_22_syscall_netbsd_386.go
│ ├── go1_22_syscall_netbsd_amd64.go
│ ├── go1_22_syscall_netbsd_arm.go
│ ├── go1_22_syscall_netbsd_arm64.go
│ ├── go1_22_syscall_openbsd_386.go
│ ├── go1_22_syscall_openbsd_amd64.go
│ ├── go1_22_syscall_openbsd_arm.go
│ ├── go1_22_syscall_openbsd_arm64.go
│ ├── go1_22_syscall_openbsd_ppc64.go
│ ├── go1_22_syscall_plan9_386.go
│ ├── go1_22_syscall_plan9_amd64.go
│ ├── go1_22_syscall_plan9_arm.go
│ ├── go1_22_syscall_solaris_amd64.go
│ ├── go1_22_syscall_wasip1_wasm.go
│ ├── go1_22_syscall_windows_386.go
│ ├── go1_22_syscall_windows_amd64.go
│ ├── go1_22_syscall_windows_arm.go
│ ├── go1_22_syscall_windows_arm64.go
│ └── syscall.go
├── unrestricted/
│ ├── go1_21_syscall_aix_ppc64.go
│ ├── go1_21_syscall_android_386.go
│ ├── go1_21_syscall_android_amd64.go
│ ├── go1_21_syscall_android_arm.go
│ ├── go1_21_syscall_android_arm64.go
│ ├── go1_21_syscall_darwin_amd64.go
│ ├── go1_21_syscall_darwin_arm64.go
│ ├── go1_21_syscall_dragonfly_amd64.go
│ ├── go1_21_syscall_freebsd_386.go
│ ├── go1_21_syscall_freebsd_amd64.go
│ ├── go1_21_syscall_freebsd_arm.go
│ ├── go1_21_syscall_freebsd_arm64.go
│ ├── go1_21_syscall_freebsd_riscv64.go
│ ├── go1_21_syscall_illumos_amd64.go
│ ├── go1_21_syscall_ios_amd64.go
│ ├── go1_21_syscall_ios_arm64.go
│ ├── go1_21_syscall_js_wasm.go
│ ├── go1_21_syscall_linux_386.go
│ ├── go1_21_syscall_linux_amd64.go
│ ├── go1_21_syscall_linux_arm.go
│ ├── go1_21_syscall_linux_arm64.go
│ ├── go1_21_syscall_linux_loong64.go
│ ├── go1_21_syscall_linux_mips.go
│ ├── go1_21_syscall_linux_mips64.go
│ ├── go1_21_syscall_linux_mips64le.go
│ ├── go1_21_syscall_linux_mipsle.go
│ ├── go1_21_syscall_linux_ppc64.go
│ ├── go1_21_syscall_linux_ppc64le.go
│ ├── go1_21_syscall_linux_riscv64.go
│ ├── go1_21_syscall_linux_s390x.go
│ ├── go1_21_syscall_netbsd_386.go
│ ├── go1_21_syscall_netbsd_amd64.go
│ ├── go1_21_syscall_netbsd_arm.go
│ ├── go1_21_syscall_netbsd_arm64.go
│ ├── go1_21_syscall_openbsd_386.go
│ ├── go1_21_syscall_openbsd_amd64.go
│ ├── go1_21_syscall_openbsd_arm.go
│ ├── go1_21_syscall_openbsd_arm64.go
│ ├── go1_21_syscall_plan9_386.go
│ ├── go1_21_syscall_plan9_amd64.go
│ ├── go1_21_syscall_plan9_arm.go
│ ├── go1_21_syscall_solaris_amd64.go
│ ├── go1_21_syscall_wasip1_wasm.go
│ ├── go1_21_syscall_windows_386.go
│ ├── go1_21_syscall_windows_amd64.go
│ ├── go1_21_syscall_windows_arm.go
│ ├── go1_21_syscall_windows_arm64.go
│ ├── go1_22_syscall_aix_ppc64.go
│ ├── go1_22_syscall_android_386.go
│ ├── go1_22_syscall_android_amd64.go
│ ├── go1_22_syscall_android_arm.go
│ ├── go1_22_syscall_android_arm64.go
│ ├── go1_22_syscall_darwin_amd64.go
│ ├── go1_22_syscall_darwin_arm64.go
│ ├── go1_22_syscall_dragonfly_amd64.go
│ ├── go1_22_syscall_freebsd_386.go
│ ├── go1_22_syscall_freebsd_amd64.go
│ ├── go1_22_syscall_freebsd_arm.go
│ ├── go1_22_syscall_freebsd_arm64.go
│ ├── go1_22_syscall_freebsd_riscv64.go
│ ├── go1_22_syscall_illumos_amd64.go
│ ├── go1_22_syscall_ios_amd64.go
│ ├── go1_22_syscall_ios_arm64.go
│ ├── go1_22_syscall_js_wasm.go
│ ├── go1_22_syscall_linux_386.go
│ ├── go1_22_syscall_linux_amd64.go
│ ├── go1_22_syscall_linux_arm.go
│ ├── go1_22_syscall_linux_arm64.go
│ ├── go1_22_syscall_linux_loong64.go
│ ├── go1_22_syscall_linux_mips.go
│ ├── go1_22_syscall_linux_mips64.go
│ ├── go1_22_syscall_linux_mips64le.go
│ ├── go1_22_syscall_linux_mipsle.go
│ ├── go1_22_syscall_linux_ppc64.go
│ ├── go1_22_syscall_linux_ppc64le.go
│ ├── go1_22_syscall_linux_riscv64.go
│ ├── go1_22_syscall_linux_s390x.go
│ ├── go1_22_syscall_netbsd_386.go
│ ├── go1_22_syscall_netbsd_amd64.go
│ ├── go1_22_syscall_netbsd_arm.go
│ ├── go1_22_syscall_netbsd_arm64.go
│ ├── go1_22_syscall_openbsd_386.go
│ ├── go1_22_syscall_openbsd_amd64.go
│ ├── go1_22_syscall_openbsd_arm.go
│ ├── go1_22_syscall_openbsd_arm64.go
│ ├── go1_22_syscall_openbsd_ppc64.go
│ ├── go1_22_syscall_plan9_386.go
│ ├── go1_22_syscall_plan9_amd64.go
│ ├── go1_22_syscall_plan9_arm.go
│ ├── go1_22_syscall_solaris_amd64.go
│ ├── go1_22_syscall_wasip1_wasm.go
│ ├── go1_22_syscall_windows_386.go
│ ├── go1_22_syscall_windows_amd64.go
│ ├── go1_22_syscall_windows_arm.go
│ ├── go1_22_syscall_windows_arm64.go
│ └── unrestricted.go
├── unsafe/
│ ├── go1_21_unsafe.go
│ ├── go1_22_unsafe.go
│ └── unsafe.go
└── wrapper-composed.go
Showing preview only (429K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5736 symbols across 1597 files)
FILE: _test/a1.go
function main (line 3) | func main() {
FILE: _test/a10.go
type Sample (line 3) | type Sample struct
function f (line 9) | func f(i int) {
function main (line 13) | func main() {
FILE: _test/a11.go
function main (line 3) | func main() {
FILE: _test/a12.go
function main (line 5) | func main() {
FILE: _test/a13.go
type T1 (line 3) | type T1 struct
function main (line 7) | func main() {
FILE: _test/a14.go
constant size (line 5) | size = 12
function main (line 7) | func main() {
FILE: _test/a15.go
constant size (line 5) | size = 12
function main (line 7) | func main() {
FILE: _test/a16.go
function main (line 3) | func main() {
FILE: _test/a17.go
function main (line 5) | func main() {
FILE: _test/a18.go
function main (line 3) | func main() {
FILE: _test/a19.go
function main (line 3) | func main() {
constant bsize (line 8) | bsize = 10
FILE: _test/a2.go
function main (line 3) | func main() {
FILE: _test/a20.go
type IntArray (line 5) | type IntArray
method Add (line 7) | func (h *IntArray) Add(x int) {
function main (line 11) | func main() {
FILE: _test/a21.go
function main (line 5) | func main() {
FILE: _test/a22.go
function main (line 3) | func main() {
FILE: _test/a23.go
function main (line 5) | func main() {
FILE: _test/a24.go
function main (line 5) | func main() {
FILE: _test/a25.go
function main (line 5) | func main() {
FILE: _test/a26.go
function main (line 3) | func main() {
FILE: _test/a27.go
function main (line 5) | func main() {
FILE: _test/a28.go
function main (line 5) | func main() {
FILE: _test/a29.go
constant zero (line 6) | zero = iota
constant one (line 7) | one
constant two (line 8) | two
constant three (line 9) | three
function main (line 12) | func main() {
FILE: _test/a3.go
function main (line 5) | func main() {
FILE: _test/a30.go
function main (line 3) | func main() {
FILE: _test/a31.go
function main (line 3) | func main() {
FILE: _test/a32.go
type T (line 5) | type T struct
function main (line 9) | func main() {
FILE: _test/a33.go
function main (line 5) | func main() {
FILE: _test/a34.go
function main (line 5) | func main() {
FILE: _test/a35.go
function main (line 5) | func main() {
FILE: _test/a36.go
function main (line 5) | func main() {
FILE: _test/a37.go
function main (line 5) | func main() {
FILE: _test/a38.go
function main (line 5) | func main() {
FILE: _test/a39.go
function main (line 5) | func main() {
FILE: _test/a4.go
function main (line 5) | func main() {
FILE: _test/a40.go
type rule (line 5) | type rule
constant r0 (line 8) | r0 rule = iota
constant r1 (line 9) | r1
constant r2 (line 10) | r2
function main (line 18) | func main() {
FILE: _test/a41.go
function main (line 5) | func main() {
FILE: _test/a42.go
function main (line 8) | func main() {
FILE: _test/a43.go
type T (line 5) | type T
constant l1 (line 8) | l1 = 2
constant l2 (line 9) | l2 = 3
function main (line 12) | func main() {
FILE: _test/a44.go
constant max (line 5) | max = 32
function main (line 7) | func main() {
FILE: _test/a5.go
function main (line 5) | func main() {
FILE: _test/a6.go
function main (line 5) | func main() {
FILE: _test/a7.go
function main (line 5) | func main() {
FILE: _test/a8.go
function main (line 5) | func main() {
FILE: _test/a9.go
function main (line 10) | func main() {
FILE: _test/add0.go
function main (line 3) | func main() {
FILE: _test/add1.go
function main (line 3) | func main() {
FILE: _test/add2.go
type iface (line 3) | type iface interface
function main (line 5) | func main() {
FILE: _test/addr0.go
type extendedRequest (line 8) | type extendedRequest struct
function main (line 14) | func main() {
FILE: _test/addr1.go
type T (line 5) | type T struct
function main (line 10) | func main() {
FILE: _test/addr2.go
type Email (line 9) | type Email struct
function f (line 14) | func f(r interface{}) error {
function withPointerAsInterface (line 18) | func withPointerAsInterface(r interface{}) error {
function ff (line 33) | func ff(s string, r interface{}) error {
function fff (line 37) | func fff(s string, r interface{}) error {
function main (line 41) | func main() {
FILE: _test/addr3.go
function main (line 7) | func main() {
FILE: _test/addr4.go
constant jsonData (line 9) | jsonData = `[
constant jsonData2 (line 14) | jsonData2 = `[
constant jsonData3 (line 19) | jsonData3 = `{
function fromSlice (line 24) | func fromSlice() {
function fromEmpty (line 40) | func fromEmpty() {
function sliceOfObjects (line 58) | func sliceOfObjects() {
function intoMap (line 72) | func intoMap() {
function main (line 99) | func main() {
FILE: _test/addr5.go
function main (line 9) | func main() {
FILE: _test/and.go
function main (line 3) | func main() {
function f1 (line 11) | func f1() bool {
function f2 (line 17) | func f2() bool {
FILE: _test/and0.go
function main (line 3) | func main() {
function f1 (line 11) | func f1() bool {
function f2 (line 16) | func f2() bool {
FILE: _test/and1.go
function main (line 3) | func main() {
function f1 (line 8) | func f1() bool {
function f2 (line 13) | func f2() bool {
FILE: _test/and2.go
function f (line 3) | func f() bool {
function main (line 8) | func main() {
FILE: _test/and3.go
function main (line 5) | func main() {
FILE: _test/append0.go
function f (line 5) | func f(a []int, b int) interface{} { return append(a, b) }
function main (line 7) | func main() {
FILE: _test/append1.go
function main (line 8) | func main() {
FILE: _test/append2.go
function main (line 8) | func main() {
FILE: _test/append3.go
function main (line 5) | func main() {
FILE: _test/append4.go
function main (line 5) | func main() {
FILE: _test/assert0.go
type MyWriter (line 8) | type MyWriter interface
type DummyWriter (line 12) | type DummyWriter interface
type TestStruct (line 16) | type TestStruct struct
method Write (line 18) | func (t TestStruct) Write(p []byte) (n int, err error) {
function usesWriter (line 22) | func usesWriter(w MyWriter) {
type MyStringer (line 27) | type MyStringer interface
type DummyStringer (line 31) | type DummyStringer interface
function usesStringer (line 35) | func usesStringer(s MyStringer) {
function main (line 39) | func main() {
FILE: _test/assert1.go
type TestStruct (line 9) | type TestStruct struct
method String (line 11) | func (t TestStruct) String() string {
type DummyStringer (line 15) | type DummyStringer interface
function main (line 19) | func main() {
FILE: _test/assert2.go
type stringBuilder (line 10) | type stringBuilder interface
function newStringBuilder (line 22) | func newStringBuilder() stringBuilder {
function main (line 26) | func main() {
FILE: _test/assert3.go
function main (line 5) | func main() {
FILE: _test/assert4.go
function main (line 6) | func main() {
FILE: _test/assign.go
function main (line 3) | func main() {
FILE: _test/assign0.go
function main (line 9) | func main() {
FILE: _test/assign1.go
function main (line 5) | func main() {
FILE: _test/assign10.go
function main (line 3) | func main() {
FILE: _test/assign11.go
function main (line 5) | func main() {
FILE: _test/assign12.go
function main (line 5) | func main() {
FILE: _test/assign13.go
function getStr (line 5) | func getStr() string {
function main (line 9) | func main() {
FILE: _test/assign14.go
function main (line 7) | func main() {
FILE: _test/assign15.go
function main (line 3) | func main() {
FILE: _test/assign16.go
type H (line 3) | type H struct
function main (line 7) | func main() {
FILE: _test/assign17.go
function main (line 3) | func main() {
FILE: _test/assign18.go
function main (line 3) | func main() {
FILE: _test/assign19.go
function main (line 3) | func main() {
FILE: _test/assign2.go
function main (line 3) | func main() {
function hello (line 9) | func hello(r uint32) uint32 { return r + 1 }
FILE: _test/assign3.go
function main (line 3) | func main() {
FILE: _test/assign4.go
function main (line 3) | func main() {
FILE: _test/assign5.go
function main (line 5) | func main() {
FILE: _test/assign6.go
function main (line 5) | func main() {
FILE: _test/assign7.go
function main (line 5) | func main() {
FILE: _test/assign8.go
function main (line 3) | func main() {
FILE: _test/assign9.go
type foo (line 3) | type foo
function boo (line 5) | func boo(b int) { println("boo", b) }
function main (line 7) | func main() {
FILE: _test/bin.go
function main (line 5) | func main() {
FILE: _test/bin0.go
function main (line 5) | func main() {
FILE: _test/bin1.go
function main (line 8) | func main() {
FILE: _test/bin2.go
function main (line 8) | func main() {
FILE: _test/bin3.go
function main (line 5) | func main() {
FILE: _test/bin4.go
function Bar (line 8) | func Bar(s string) bool {
function main (line 16) | func main() {
FILE: _test/bin5.go
function main (line 8) | func main() {
FILE: _test/binstruct_ptr_map0.go
function main (line 8) | func main() {
FILE: _test/binstruct_ptr_slice0.go
function main (line 8) | func main() {
FILE: _test/binstruct_slice0.go
function main (line 8) | func main() {
FILE: _test/bltn.go
function main (line 3) | func main() {
FILE: _test/bltn0.go
function main (line 3) | func main() {
FILE: _test/bool.go
function main (line 5) | func main() {
FILE: _test/bool0.go
function main (line 5) | func main() {
FILE: _test/bool1.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/bool2.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/bool3.go
function main (line 3) | func main() {
FILE: _test/bool4.go
function main (line 3) | func main() {
FILE: _test/bool5.go
function main (line 3) | func main() {
FILE: _test/break0.go
function main (line 3) | func main() {
FILE: _test/break1.go
function main (line 3) | func main() {
FILE: _test/break2.go
function main (line 3) | func main() {
FILE: _test/break3.go
function main (line 3) | func main() {
FILE: _test/cap0.go
function f (line 3) | func f(a []int) interface{} {
function g (line 7) | func g(a []int) int {
function main (line 11) | func main() {
FILE: _test/chan0.go
type Channel (line 3) | type Channel
function send (line 5) | func send(c Channel) { c <- "ping" }
function main (line 7) | func main() {
FILE: _test/chan1.go
function send (line 3) | func send(c chan<- string) { c <- "ping" }
function main (line 5) | func main() {
FILE: _test/chan10.go
function main (line 5) | func main() {
FILE: _test/chan2.go
function main (line 5) | func main() {
FILE: _test/chan3.go
function send (line 3) | func send(c chan<- int32) { c <- 123 }
function main (line 5) | func main() {
FILE: _test/chan4.go
function send (line 3) | func send(c chan<- bool) { c <- false }
function main (line 5) | func main() {
FILE: _test/chan5.go
function main (line 5) | func main() {
FILE: _test/chan6.go
function send (line 3) | func send(c chan<- int32) { c <- 123 }
function main (line 5) | func main() {
FILE: _test/chan7.go
function main (line 5) | func main() {
FILE: _test/chan8.go
function main (line 3) | func main() {
FILE: _test/chan9.go
type Channel (line 3) | type Channel
type T (line 5) | type T struct
function send (line 9) | func send(c Channel) { c <- "ping" }
function main (line 11) | func main() {
FILE: _test/cli1.go
function client (line 11) | func client(uri string) {
function server (line 23) | func server(ln net.Listener, ready chan bool) {
function main (line 33) | func main() {
FILE: _test/cli2.go
type T (line 11) | type T struct
method Close (line 15) | func (t *T) Close() {
function client (line 19) | func client(uri string) {
function server (line 31) | func server(ln net.Listener, ready chan bool) {
function main (line 41) | func main() {
FILE: _test/cli3.go
function client (line 11) | func client(uri string) {
function main (line 23) | func main() {
FILE: _test/cli4.go
type mw1 (line 11) | type mw1 struct
method ServeHTTP (line 15) | func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
type mw0 (line 19) | type mw0 struct
method ServeHTTP (line 21) | func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
function main (line 25) | func main() {
function client (line 38) | func client(uri string) {
FILE: _test/cli5.go
type mw1 (line 11) | type mw1 struct
method ServeHTTP (line 15) | func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
type mw0 (line 19) | type mw0 struct
method ServeHTTP (line 21) | func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
function main (line 25) | func main() {
function client (line 38) | func client(uri string) {
FILE: _test/cli6.go
type T (line 11) | type T struct
type mw1 (line 15) | type mw1 struct
method ServeHTTP (line 19) | func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
function main (line 27) | func main() {
function client (line 39) | func client(uri string) {
FILE: _test/cli7.go
type T (line 11) | type T struct
type mw1 (line 15) | type mw1 struct
method ServeHTTP (line 20) | func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
function main (line 29) | func main() {
function client (line 43) | func client(uri string) {
FILE: _test/cli8.go
type T (line 8) | type T struct
method ServeHTTP (line 13) | func (t *T) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
function New (line 20) | func New(name string, next http.Handler) (http.Handler, error) { return ...
function main (line 22) | func main() {
FILE: _test/closure0.go
type adder (line 3) | type adder
function genAdd (line 5) | func genAdd(k int) adder {
function main (line 11) | func main() {
FILE: _test/closure1.go
type adder (line 3) | type adder
function genAdd (line 5) | func genAdd(k int) adder {
function main (line 11) | func main() {
FILE: _test/closure10.go
function main (line 3) | func main() {
FILE: _test/closure11.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/closure12.go
type T (line 5) | type T struct
function main (line 9) | func main() {
FILE: _test/closure13.go
type monkey (line 8) | type monkey struct
function main (line 12) | func main() {
FILE: _test/closure14.go
type monkey (line 5) | type monkey struct
function getk (line 9) | func getk(k int) (int, error) { return k, nil }
function main (line 11) | func main() {
FILE: _test/closure15.go
function main (line 3) | func main() {
FILE: _test/closure16.go
function main (line 3) | func main() {
FILE: _test/closure17.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/closure18.go
type T (line 5) | type T struct
function main (line 9) | func main() {
FILE: _test/closure19.go
function main (line 3) | func main() {
FILE: _test/closure2.go
function adder (line 3) | func adder() func(int) int {
function main (line 11) | func main() {
FILE: _test/closure20.go
function main (line 3) | func main() {
FILE: _test/closure3.go
type T1 (line 3) | type T1 struct
method genAdd (line 7) | func (t *T1) genAdd(k int) func(int) int {
function main (line 16) | func main() {
FILE: _test/closure4.go
type T1 (line 3) | type T1 struct
method genAdd (line 7) | func (t *T1) genAdd(k int) func(int) int {
function main (line 16) | func main() {
FILE: _test/closure5.go
type T1 (line 3) | type T1 struct
method genAdd (line 7) | func (t T1) genAdd(k int) func(int) int {
function main (line 16) | func main() {
FILE: _test/closure6.go
type T1 (line 3) | type T1 struct
method genAdd (line 7) | func (t *T1) genAdd(k int) func(int) int {
function main (line 16) | func main() {
FILE: _test/closure7.go
type Config (line 7) | type Config struct
function SetConfig (line 13) | func SetConfig() func(*Config) {
function main (line 19) | func main() {
FILE: _test/closure8.go
function main (line 5) | func main() {
FILE: _test/closure9.go
function main (line 3) | func main() {
FILE: _test/comp0.go
function main (line 3) | func main() {
FILE: _test/comp1.go
function main (line 3) | func main() {
FILE: _test/comp2.go
type delta (line 3) | type delta
function main (line 5) | func main() {
FILE: _test/complex0.go
function main (line 5) | func main() {
FILE: _test/complex1.go
function main (line 5) | func main() {
FILE: _test/complex2.go
function main (line 5) | func main() {
FILE: _test/complex3.go
function main (line 5) | func main() {
FILE: _test/complex4.go
function f (line 5) | func f(a, b float64) interface{} { return complex(a, b) }
function main (line 7) | func main() {
FILE: _test/composite0.go
type T (line 7) | type T struct
function main (line 9) | func main() {
FILE: _test/composite1.go
type T (line 7) | type T struct
function main (line 9) | func main() {
FILE: _test/composite10.go
function main (line 5) | func main() {
FILE: _test/composite11.go
function main (line 8) | func main() {
FILE: _test/composite12.go
type A (line 3) | type A struct
type D (line 7) | type D struct
function main (line 11) | func main() {
FILE: _test/composite13.go
type A (line 3) | type A struct
type D (line 7) | type D struct
function main (line 11) | func main() {
FILE: _test/composite14.go
type T (line 5) | type T struct
function main (line 9) | func main() {
FILE: _test/composite15.go
function interfaceAsInts (line 7) | func interfaceAsInts() {
function interfaceAsInterfaces (line 24) | func interfaceAsInterfaces() {
function main (line 42) | func main() {
FILE: _test/composite16.go
function main (line 8) | func main() {
FILE: _test/composite17.go
function main (line 9) | func main() {
function stringOr (line 22) | func stringOr(v, def string) string {
FILE: _test/composite18.go
type fn (line 5) | type fn
function cmpLessFn (line 13) | func cmpLessFn(a string, b string) bool {
function cmpGreaterFn (line 17) | func cmpGreaterFn(a string, b string) bool {
function main (line 21) | func main() {
FILE: _test/composite19.go
type fn (line 5) | type fn
function cmpLessFn (line 13) | func cmpLessFn(a string, b string) bool {
function cmpGreaterFn (line 17) | func cmpGreaterFn(a string, b string) bool {
function main (line 21) | func main() {
FILE: _test/composite2.go
type T (line 7) | type T struct
function main (line 9) | func main() {
FILE: _test/composite3.go
function main (line 3) | func main() {
FILE: _test/composite4.go
function main (line 3) | func main() {
FILE: _test/composite5.go
type T (line 5) | type T struct
function main (line 11) | func main() {
FILE: _test/composite6.go
type T (line 9) | type T struct
function main (line 15) | func main() {
FILE: _test/composite7.go
type T (line 3) | type T struct
function main (line 13) | func main() {
FILE: _test/composite8.go
type T (line 3) | type T struct
function main (line 5) | func main() {
FILE: _test/composite8bis.go
type T (line 3) | type T struct
function main (line 5) | func main() {
FILE: _test/composite9.go
function main (line 5) | func main() {
FILE: _test/const0.go
constant a (line 4) | a = iota
constant b (line 5) | b
function main (line 8) | func main() {
FILE: _test/const1.go
type T (line 3) | type T struct
function main (line 10) | func main() {
FILE: _test/const10.go
constant a (line 4) | a = 2
constant b (line 5) | b = c + d
constant c (line 6) | c = a + d
constant d (line 7) | d = e + f
constant e (line 8) | e = 3
constant f (line 9) | f = 4
function main (line 12) | func main() {
FILE: _test/const11.go
function main (line 3) | func main() {
FILE: _test/const12.go
type Kind (line 3) | type Kind
constant None (line 6) | None Kind = 0
constant Left (line 7) | Left Kind = 1 << iota
constant Right (line 8) | Right
constant Both (line 9) | Both Kind = Left | Right
function main (line 12) | func main() {
FILE: _test/const13.go
function main (line 7) | func main() {
FILE: _test/const14.go
function f1 (line 5) | func f1(i int) { println("i:", i) }
function main (line 7) | func main() {
FILE: _test/const15.go
type T1 (line 3) | type T1
type t1 (line 5) | type t1
constant P2 (line 8) | P2 T1 = 2
constant P3 (line 9) | P3 T1 = 3
function main (line 12) | func main() {
FILE: _test/const16.go
function main (line 7) | func main() {
FILE: _test/const17.go
function main (line 7) | func main() {
FILE: _test/const18.go
function main (line 5) | func main() {
FILE: _test/const19.go
function get10Hours (line 8) | func get10Hours() time.Duration {
function main (line 12) | func main() {
FILE: _test/const2.go
function main (line 3) | func main() {
constant a (line 7) | a = "hello"
FILE: _test/const20.go
constant maxLen (line 5) | maxLen = int64(int64(^uint64(0) >> 1))
function main (line 7) | func main() {
FILE: _test/const21.go
constant a (line 3) | a = 64
function main (line 7) | func main() {
FILE: _test/const22.go
constant numDec (line 4) | numDec uint8 = (1 << iota) / 2
constant numHex (line 5) | numHex
constant numOct (line 6) | numOct
constant numFloat (line 7) | numFloat
function main (line 10) | func main() {
FILE: _test/const23.go
constant maxlen (line 3) | maxlen = len("hello")
function main (line 7) | func main() {
FILE: _test/const24.go
constant maxlen (line 5) | maxlen = cap(aa)
function main (line 9) | func main() {
FILE: _test/const25.go
constant FGBlack (line 4) | FGBlack Attribute = iota + 30
type Attribute (line 7) | type Attribute
function main (line 9) | func main() {
FILE: _test/const26.go
function init (line 7) | func init() {
constant constString (line 13) | constString string = "hello"
constant const1 (line 16) | const1 = iota + 10
constant const2 (line 17) | const2
constant const3 (line 18) | const3
function main (line 23) | func main() {}
FILE: _test/const3.go
constant a (line 3) | a, b, c int = 1, 2, 3
function main (line 5) | func main() { println(a, b, c) }
FILE: _test/const4.go
constant a (line 4) | a = 2
constant b (line 5) | b = 3
constant c (line 6) | c
function main (line 9) | func main() {
FILE: _test/const5.go
constant a (line 8) | a uint8 = 2 * iota
constant b (line 9) | b
constant c (line 10) | c
function main (line 13) | func main() {
FILE: _test/const6.go
constant maxNonStarters (line 4) | maxNonStarters = 30
constant maxBufferSize (line 5) | maxBufferSize = maxNonStarters + 2
type reorderBuffer (line 8) | type reorderBuffer struct
type Properties (line 12) | type Properties struct
function main (line 17) | func main() {
FILE: _test/const7.go
constant a (line 6) | a = iota
constant b (line 7) | b
constant c (line 8) | c
constant d (line 9) | d
type T (line 12) | type T
function main (line 14) | func main() {
FILE: _test/const8.go
constant a (line 4) | a = 2
constant b (line 5) | b = c + d
constant c (line 6) | c = 4
constant d (line 7) | d = 5
function main (line 10) | func main() {
FILE: _test/const9.go
constant a (line 4) | a = 2
constant b (line 5) | b = c + d
constant c (line 6) | c = a + d
constant d (line 7) | d = e + f
constant e (line 8) | e = b + 2
constant f (line 9) | f = 4
function main (line 12) | func main() {
FILE: _test/cont.go
function main (line 3) | func main() {
FILE: _test/cont0.go
function main (line 3) | func main() {
FILE: _test/cont1.go
function main (line 3) | func main() {
FILE: _test/cont2.go
function main (line 3) | func main() {
FILE: _test/cont3.go
function main (line 3) | func main() {
FILE: _test/context.go
function get (line 5) | func get(ctx context.Context, k string) string {
function main (line 13) | func main() {
FILE: _test/context2.go
function get (line 5) | func get(ctx context.Context, k string) string {
function main (line 15) | func main() {
FILE: _test/convert0.go
type T (line 3) | type T struct
type comparator (line 7) | type comparator
function sort (line 9) | func sort(items []T, comp comparator) {
function compT (line 13) | func compT(t0, t1 T) bool { return t0.v < t1.v }
function main (line 15) | func main() {
FILE: _test/convert1.go
type atoidef (line 5) | type atoidef
function main (line 7) | func main() {
FILE: _test/convert2.go
function fakeSplitFunc (line 5) | func fakeSplitFunc(data []byte, atEOF bool) (advance int, token []byte, ...
function main (line 9) | func main() {
FILE: _test/convert3.go
function main (line 8) | func main() {
FILE: _test/copy0.go
function main (line 5) | func main() {
FILE: _test/copy1.go
function main (line 5) | func main() {
FILE: _test/copy2.go
function f (line 5) | func f(a, b []int) interface{} { return copy(a, b) }
function main (line 7) | func main() {
FILE: _test/ct/ct1.go
function init (line 3) | func init() { println("hello from ct1") }
FILE: _test/ct/ct2.go
function init (line 5) | func init() { println("hello from ct2") }
FILE: _test/ct/ct3.go
function init (line 5) | func init() { println("hello from ct3") }
FILE: _test/ct1/ct1.go
type Class (line 3) | type Class
constant L (line 6) | L Class = iota
constant R (line 7) | R
constant AL (line 8) | AL
FILE: _test/d1/d1.go
type T (line 3) | type T struct
method F (line 7) | func (t *T) F() { println(t.Name) }
function NewT (line 9) | func NewT(s string) *T { return &T{s} }
FILE: _test/d3.go
function main (line 5) | func main() {
FILE: _test/defer0.go
function main (line 5) | func main() {
FILE: _test/defer1.go
function main (line 5) | func main() {
FILE: _test/defer2.go
function main (line 5) | func main() {
FILE: _test/defer3.go
function main (line 8) | func main() {
FILE: _test/defer4.go
type T (line 5) | type T struct
method get (line 10) | func (t *T) get() string {
function main (line 18) | func main() {
FILE: _test/defer5.go
function f1 (line 3) | func f1() {
function f2 (line 9) | func f2() {
function f3 (line 15) | func f3() {
function main (line 21) | func main() {
FILE: _test/defer6.go
function f1 (line 3) | func f1() {
function f2 (line 9) | func f2() {
function f3 (line 15) | func f3() {
function main (line 21) | func main() {
FILE: _test/defer7.go
function f1 (line 5) | func f1(in, out []string) {
function main (line 9) | func main() {
FILE: _test/defer8.go
function f1 (line 5) | func f1(m map[string]string) {
function main (line 12) | func main() {
FILE: _test/defer9.go
function f1 (line 5) | func f1(ch chan string) {
function main (line 11) | func main() {
FILE: _test/delete0.go
function main (line 5) | func main() {
FILE: _test/eval0.go
function main (line 10) | func main() {
FILE: _test/export0.go
function Test (line 3) | func Test() {
FILE: _test/export1.go
type Sample (line 3) | type Sample struct
method Test (line 5) | func (s *Sample) Test() {
FILE: _test/factor.go
function main (line 8) | func main() {
FILE: _test/fib.go
function fib (line 4) | func fib(n int) int {
function main (line 11) | func main() {
FILE: _test/fib0.go
function fib (line 4) | func fib(n int) int {
function main (line 11) | func main() {
FILE: _test/file_access.go
function main (line 8) | func main() {
FILE: _test/flag0.go
function main (line 8) | func main() {
FILE: _test/foo/bar.go
function init (line 8) | func init() { println("init foo") }
FILE: _test/foo/boo/boo.go
function init (line 5) | func init() { println("init boo") }
FILE: _test/for0.go
function main (line 3) | func main() {
FILE: _test/for1.go
function main (line 3) | func main() {
FILE: _test/for10.go
function main (line 3) | func main() {
FILE: _test/for11.go
function main (line 3) | func main() {
FILE: _test/for12.go
function main (line 3) | func main() {
FILE: _test/for13.go
function main (line 3) | func main() {
FILE: _test/for14.go
function main (line 3) | func main() {
FILE: _test/for15.go
function f (line 3) | func f() int { println("in f"); return 1 }
function main (line 5) | func main() {
FILE: _test/for16.go
function main (line 3) | func main() {
FILE: _test/for17.go
function main (line 3) | func main() {
FILE: _test/for18.go
function main (line 3) | func main() {
FILE: _test/for19.go
function main (line 3) | func main() {
FILE: _test/for2.go
function main (line 3) | func main() {
FILE: _test/for3.go
function main (line 8) | func main() {
FILE: _test/for4.go
function main (line 3) | func main() {
FILE: _test/for5.go
function main (line 3) | func main() {
FILE: _test/for6.go
function main (line 5) | func main() {
FILE: _test/for7.go
function main (line 3) | func main() {
FILE: _test/for8.go
function main (line 3) | func main() {
FILE: _test/for9.go
function main (line 3) | func main() {
FILE: _test/fun.go
function f (line 3) | func f(i int) int { return i + 15 }
function main (line 5) | func main() {
FILE: _test/fun10.go
function f (line 5) | func f() func() {
function main (line 9) | func main() {
FILE: _test/fun11.go
type F (line 5) | type F
function main (line 7) | func main() {
FILE: _test/fun12.go
function use (line 3) | func use(interface{}) {}
function main (line 5) | func main() {
FILE: _test/fun13.go
type T (line 5) | type T struct
function newT (line 7) | func newT() (T, error) { return T{}, nil }
function main (line 9) | func main() {
FILE: _test/fun14.go
function f (line 3) | func f() (bool, int) { return true, 2 }
function g (line 5) | func g() (bool, int) { return f() }
function main (line 7) | func main() {
FILE: _test/fun15.go
function f1 (line 3) | func f1(a int) interface{} { return a + 1 }
function f2 (line 5) | func f2(a int64) interface{} { return a + 1 }
function main (line 7) | func main() {
FILE: _test/fun16.go
function f1 (line 3) | func f1(a int) int { return a + 1 }
function f2 (line 5) | func f2(a int) interface{} {
function main (line 13) | func main() {
FILE: _test/fun17.go
function f1 (line 3) | func f1(a int) interface{} { return a + 1 }
function f2 (line 5) | func f2(a int) interface{} { return f1(a) }
function main (line 7) | func main() {
FILE: _test/fun18.go
function f (line 5) | func f(s string) interface{} { return m[s] }
function main (line 7) | func main() {
FILE: _test/fun19.go
function foo (line 7) | func foo() ([]string, error) {
function main (line 11) | func main() {
FILE: _test/fun2.go
type Coord (line 3) | type Coord struct
function f (line 5) | func f(c Coord) int { return c.x + c.y }
function main (line 7) | func main() {
FILE: _test/fun20.go
function ferr (line 7) | func ferr() error { return myerr }
function foo (line 9) | func foo() ([]string, error) {
function main (line 13) | func main() {
FILE: _test/fun21.go
function Bar (line 3) | func Bar() string {
function main (line 7) | func main() {
FILE: _test/fun22.go
function main (line 5) | func main() {
FILE: _test/fun23.go
function f (line 3) | func f(x int) { return x }
function main (line 5) | func main() {
FILE: _test/fun24.go
function f (line 3) | func f(x int) (int, int) { return x, "foo" }
function main (line 5) | func main() {
FILE: _test/fun25.go
function f (line 3) | func f(x string) (a int, b int) { return x, 5 }
function main (line 5) | func main() {
FILE: _test/fun26.go
type F (line 3) | type F
function f1 (line 5) | func f1() (int, error) { return 3, nil }
function f2 (line 7) | func f2(a string, f F) {
function main (line 12) | func main() {
FILE: _test/fun27.go
function main (line 8) | func main() {
function print (line 20) | func print(state string) {
FILE: _test/fun28.go
type T (line 7) | type T struct
function finalize (line 11) | func finalize(t *T) { println("finalize") }
function newT (line 13) | func newT() *T {
function main (line 19) | func main() {
FILE: _test/fun3.go
type Coord (line 3) | type Coord struct
function f (line 5) | func f(i, j int, c Coord) int { return i*c.x + j*c.y }
function main (line 7) | func main() {
FILE: _test/fun4.go
function f (line 3) | func f() {}
function main (line 5) | func main() {
FILE: _test/fun5.go
function f (line 3) | func f(i int64) {
function main (line 7) | func main() {
FILE: _test/fun6.go
function NewPool (line 8) | func NewPool() Pool { return Pool{} }
type Pool (line 10) | type Pool struct
function main (line 16) | func main() {
FILE: _test/fun7.go
function Foo (line 8) | func Foo(goflag *goflag.Flag) {
function main (line 12) | func main() {
FILE: _test/fun8.go
function main (line 3) | func main() { println(f == nil) }
FILE: _test/fun9.go
type T (line 3) | type T
function main (line 5) | func main() {
FILE: _test/gen1.go
function SumInts (line 6) | func SumInts(m map[string]int64) int64 {
function SumFloats (line 15) | func SumFloats(m map[string]float64) float64 {
function main (line 23) | func main() {
FILE: _test/gen10.go
function genFunc (line 3) | func genFunc() (f func()) {
function main (line 7) | func main() {
FILE: _test/gen11.go
type Slice (line 9) | type Slice struct
type IPPrefixSlice (line 13) | type IPPrefixSlice struct
method MarshalJSON (line 20) | func (v IPPrefixSlice) MarshalJSON() ([]byte, error) {
method MarshalJSON (line 17) | func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v....
function main (line 24) | func main() {
FILE: _test/gen12.go
function MapOf (line 7) | func MapOf[K comparable, V any](m map[K]V) Map[K, V] {
type Map (line 11) | type Map struct
type VMap (line 17) | type VMap struct
type MapView (line 21) | type MapView struct
method Int (line 15) | func (v MapView) Int() Map[string, int] { return MapOf(v.ж.Int) }
function main (line 25) | func main() {
FILE: _test/gen13.go
type Map (line 3) | type Map struct
method Has (line 7) | func (m Map[K, V]) Has(k K) bool {
function main (line 12) | func main() {
FILE: _test/gen2.go
function SumIntsOrFloats (line 7) | func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
function main (line 15) | func main() {
FILE: _test/gen3.go
type Number (line 3) | type Number interface
function Sum (line 7) | func Sum[T Number](numbers []T) T {
function main (line 15) | func main() {
FILE: _test/gen4.go
type List (line 5) | type List struct
type element (line 10) | type element struct
method Push (line 15) | func (lst *List[T]) Push(v T) {
method GetAll (line 25) | func (lst *List[T]) GetAll() []T {
function main (line 33) | func main() {
FILE: _test/gen5.go
type Set (line 5) | type Set struct
function Make (line 9) | func Make[Elem comparable]() Set[Elem] {
method Add (line 13) | func (s Set[Elem]) Add(v Elem) {
function main (line 17) | func main() {
FILE: _test/gen6.go
function MapKeys (line 3) | func MapKeys[K comparable, V any](m map[K]V) []K {
function main (line 11) | func main() {
FILE: _test/gen7.go
function MapKeys (line 3) | func MapKeys[K comparable, V any](m map[K]V) []K {
function main (line 11) | func main() {
FILE: _test/gen8.go
type Float (line 3) | type Float interface
function add (line 7) | func add[T Float](a, b T) float64 { return float64(a) + float64(b) }
function main (line 9) | func main() {
FILE: _test/gen9.go
type Float (line 3) | type Float interface
function add (line 7) | func add[T Float](a, b T) float64 { return float64(a) + float64(b) }
function main (line 9) | func main() {
FILE: _test/goto0.go
function main (line 3) | func main() {
FILE: _test/goto1.go
function main (line 3) | func main() {
FILE: _test/heap.go
type IntHeap (line 10) | type IntHeap
method Len (line 12) | func (h IntHeap) Len() int { return len(h) }
method Less (line 13) | func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
method Swap (line 14) | func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
method Push (line 16) | func (h *IntHeap) Push(x interface{}) {
method Pop (line 22) | func (h *IntHeap) Pop() interface{} {
function main (line 32) | func main() {
FILE: _test/if.go
function main (line 3) | func main() {
function f (line 9) | func f() int { return 1 }
FILE: _test/if0.go
function main (line 3) | func main() {
FILE: _test/if1.go
function main (line 3) | func main() {
FILE: _test/if2.go
function main (line 5) | func main() {
FILE: _test/if3.go
function main (line 3) | func main() {
FILE: _test/if4.go
constant bad (line 3) | bad = false
function main (line 5) | func main() {
FILE: _test/if5.go
function main (line 3) | func main() {
FILE: _test/if6.go
function main (line 3) | func main() {
FILE: _test/if7.go
function main (line 3) | func main() {
FILE: _test/imag0.go
function f (line 5) | func f(c complex128) interface{} { return imag(c) }
function main (line 7) | func main() {
FILE: _test/import0.go
function main (line 5) | func main() {
FILE: _test/import1.go
function main (line 5) | func main() {
FILE: _test/import2.go
function main (line 5) | func main() {
FILE: _test/import3.go
function main (line 5) | func main() { println(foo.Bar, foo.Boo) }
FILE: _test/import4.go
function main (line 5) | func main() { println("num:", p1.Uint32()) }
FILE: _test/import5.go
function main (line 5) | func main() { println(boo.Bar, boo.Boo, boo.Bir) }
FILE: _test/import6.go
function main (line 5) | func main() {
FILE: _test/import7.go
function main (line 5) | func main() {
FILE: _test/import8.go
function main (line 5) | func main() {
FILE: _test/import9.go
function main (line 5) | func main() {
FILE: _test/inc.go
function main (line 3) | func main() {
FILE: _test/inception.go
function main (line 9) | func main() {
FILE: _test/init0.go
function init (line 3) | func init() {
function init (line 7) | func init() {
function main (line 11) | func main() {
FILE: _test/init1.go
function init (line 3) | func init() {
function main (line 7) | func main() {
FILE: _test/interface0.go
type sample (line 3) | type sample struct
function run (line 7) | func run(inf interface{}, name string) {
function main (line 12) | func main() {
FILE: _test/interface1.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 13) | func (b *Boo) Hello() {
function inCall (line 18) | func inCall(foo fii) {
function main (line 23) | func main() {
FILE: _test/interface10.go
type Edge (line 3) | type Edge interface
function main (line 7) | func main() {
FILE: _test/interface11.go
type Error (line 5) | type Error interface
type MyError (line 10) | type MyError
type T (line 12) | type T struct
method Error (line 16) | func (t *T) Error() string { return "err: " + t.Name }
method Code (line 17) | func (t *T) Code() string { return "code: " + t.Name }
function newT (line 19) | func newT(s string) MyError { return &T{s} }
function main (line 21) | func main() {
FILE: _test/interface12.go
type I1 (line 3) | type I1 interface
type T1 (line 7) | type T1 struct
method Truc (line 9) | func (T1) Truc() { println("in T1 truc") }
function main (line 13) | func main() {
FILE: _test/interface13.go
type X (line 7) | type X struct
method Foo (line 9) | func (X) Foo() int {
method Bar (line 12) | func (X) Bar() int {
type Foo (line 16) | type Foo interface
type Bar (line 19) | type Bar interface
function main (line 23) | func main() {
FILE: _test/interface14.go
type T (line 3) | type T struct
method Error (line 5) | func (t *T) Error() string { return "T: error" }
function main (line 9) | func main() {
FILE: _test/interface15.go
type Fooer (line 3) | type Fooer interface
type Barer (line 7) | type Barer interface
type T (line 13) | type T struct
method Foo (line 15) | func (t *T) Foo() string { return "T: foo" }
method Bar (line 16) | func (*T) Bar() { println("in bar") }
function main (line 20) | func main() {
FILE: _test/interface16.go
type Barer (line 5) | type Barer interface
type T (line 10) | type T struct
method String (line 12) | func (*T) String() string { return "T: nothing" }
method Bar (line 13) | func (*T) Bar() { println("in bar") }
function main (line 17) | func main() {
FILE: _test/interface17.go
type T (line 3) | type T struct
method Error (line 5) | func (t T) Error() string { return "T: error" }
function main (line 9) | func main() {
FILE: _test/interface18.go
type T (line 3) | type T struct
method Error (line 5) | func (t *T) Error() string { return "T: error" }
method Foo (line 6) | func (*T) Foo() { println("foo") }
function main (line 10) | func main() {
FILE: _test/interface19.go
function main (line 7) | func main() {
FILE: _test/interface2.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 17) | func (b Boo) Hello() {
type Bar (line 13) | type Bar struct
method Hello (line 15) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 22) | func inCall(foo fii) {
function main (line 32) | func main() {
FILE: _test/interface20.go
function main (line 5) | func main() {
FILE: _test/interface21.go
function main (line 5) | func main() {
FILE: _test/interface22.go
function main (line 5) | func main() {
FILE: _test/interface23.go
function main (line 5) | func main() {
FILE: _test/interface24.go
function main (line 5) | func main() {
FILE: _test/interface25.go
function main (line 5) | func main() {
FILE: _test/interface26.go
function main (line 5) | func main() {
FILE: _test/interface27.go
function main (line 7) | func main() {
FILE: _test/interface28.go
function main (line 7) | func main() {
FILE: _test/interface29.go
function main (line 3) | func main() {
FILE: _test/interface3.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 13) | func (b Boo) Hello() {
function inCall (line 18) | func inCall(foo fii) {
function main (line 23) | func main() {
FILE: _test/interface30.go
function main (line 3) | func main() {
FILE: _test/interface31.go
function main (line 5) | func main() {
FILE: _test/interface32.go
function main (line 5) | func main() {
FILE: _test/interface33.go
function main (line 5) | func main() {
FILE: _test/interface34.go
function main (line 5) | func main() {
FILE: _test/interface35.go
type T (line 5) | type T struct
function main (line 9) | func main() {
FILE: _test/interface36.go
type S (line 11) | type S struct
method F (line 15) | func (s *S) F() int { return len(s.Name) }
method G (line 16) | func (s *S) G() int { return s.F() }
method Ri (line 17) | func (s *S) Ri() I { return s }
method Rj (line 18) | func (s *S) Rj() J { return s }
type J (line 20) | type J interface
type I (line 26) | type I interface
function main (line 31) | func main() {
FILE: _test/interface37.go
type I (line 3) | type I interface
type s (line 8) | type s struct
method A (line 14) | func (c *s) A() string { return "a" }
method B (line 15) | func (c *s) B() string { return "b" }
function NewS (line 10) | func NewS() (I, error) {
function main (line 17) | func main() {
FILE: _test/interface38.go
type foo (line 5) | type foo struct
method String (line 9) | func (f foo) String() string {
function main (line 13) | func main() {
FILE: _test/interface39.go
type foo (line 5) | type foo struct
method String (line 9) | func (f *foo) String() string {
function main (line 13) | func main() {
FILE: _test/interface4.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 17) | func (b Boo) Hello() {
type Bir (line 13) | type Bir struct
function inCall (line 22) | func inCall(foo fii) {
function main (line 27) | func main() {
FILE: _test/interface40.go
type foo (line 5) | type foo struct
method String (line 9) | func (f foo) String() string {
function Foo (line 13) | func Foo(s string) fmt.Stringer {
function main (line 17) | func main() {
FILE: _test/interface41.go
type foo (line 5) | type foo struct
method String (line 9) | func (f *foo) String() string {
function Foo (line 13) | func Foo(s string) fmt.Stringer {
function main (line 17) | func main() {
FILE: _test/interface42.go
function main (line 5) | func main() {
FILE: _test/interface43.go
function main (line 5) | func main() {
FILE: _test/interface44.go
type S (line 3) | type S struct
function main (line 7) | func main() {
FILE: _test/interface45.go
function main (line 5) | func main() {
FILE: _test/interface46.go
type I (line 5) | type I interface
type Printer (line 9) | type Printer struct
method Print (line 19) | func (p *Printer) Print() {
function New (line 13) | func New(i I) *Printer {
type T (line 23) | type T struct
method Foo (line 25) | func (t *T) Foo() string {
function main (line 29) | func main() {
FILE: _test/interface47.go
type Doer (line 3) | type Doer interface
type T (line 7) | type T struct
method Do (line 11) | func (t *T) Do() error { println("in do"); return nil }
function f (line 13) | func f() (Doer, error) { return &T{"truc"}, nil }
type Ev (line 15) | type Ev struct
method do (line 19) | func (e *Ev) do() {
function main (line 24) | func main() {
FILE: _test/interface48.go
type I1 (line 5) | type I1 interface
type I2 (line 9) | type I2 interface
function main (line 11) | func main() {
FILE: _test/interface49.go
type Descriptor (line 3) | type Descriptor interface
type FileDescriptor (line 7) | type FileDescriptor interface
type EnumDescriptors (line 12) | type EnumDescriptors interface
type EnumDescriptor (line 16) | type EnumDescriptor interface
type EnumValueDescriptors (line 20) | type EnumValueDescriptors interface
type EnumValueDescriptor (line 24) | type EnumValueDescriptor interface
type ServiceDescriptors (line 28) | type ServiceDescriptors interface
type ServiceDescriptor (line 32) | type ServiceDescriptor interface
type isServiceDescriptor (line 37) | type isServiceDescriptor interface
function main (line 39) | func main() {
FILE: _test/interface5.go
type Myint (line 5) | type Myint
method Double (line 7) | func (i Myint) Double() { fmt.Println("Myint:", i, i) }
type Boo (line 9) | type Boo interface
function f (line 13) | func f(boo Boo) {
function main (line 17) | func main() {
FILE: _test/interface50.go
function main (line 3) | func main() {
FILE: _test/interface51.go
type Error (line 3) | type Error interface
type T (line 8) | type T struct
method Error (line 12) | func (t *T) Error() string { return t.Msg }
method Message (line 13) | func (t *T) Message() string { return "message:" + t.Msg }
function newError (line 15) | func newError() Error { return &T{"test"} }
function main (line 17) | func main() {
FILE: _test/interface52.go
function main (line 5) | func main() {
FILE: _test/interface6.go
type Myint (line 5) | type Myint
method Double (line 7) | func (i Myint) Double() { fmt.Println("Myint:", i, i) }
type Boo (line 9) | type Boo interface
function f (line 13) | func f(boo Boo) { boo.Double() }
function g (line 15) | func g(i int) Boo { return Myint(i) }
function main (line 17) | func main() {
FILE: _test/interface7.go
type T (line 5) | type T
method Error (line 7) | func (t T) Error() string { return fmt.Sprintf("This is an error from ...
function f (line 9) | func f(t T) error { return t }
function main (line 11) | func main() {
FILE: _test/interface8.go
type HelloInterface (line 9) | type HelloInterface interface
type Hello (line 13) | type Hello struct
method Hi (line 15) | func (h *Hello) Hi() string {
function main (line 19) | func main() {
FILE: _test/interface9.go
type Int (line 5) | type Int
method String (line 7) | func (I Int) String() string {
function main (line 11) | func main() {
FILE: _test/io0.go
function main (line 9) | func main() {
FILE: _test/io1.go
function main (line 8) | func main() {
FILE: _test/io2.go
function main (line 10) | func main() {
FILE: _test/iota.go
constant Foo (line 6) | Foo = iota
constant Bar (line 7) | Bar
constant Baz (line 8) | Baz
constant Asm (line 12) | Asm = iota
constant C (line 13) | C
constant Java (line 14) | Java
constant Go (line 15) | Go
function main (line 18) | func main() {
FILE: _test/iota0.go
function main (line 5) | func main() {
FILE: _test/ipp_as_key.go
function main (line 8) | func main() {
FILE: _test/issue-1007.go
type TypeA (line 3) | type TypeA struct
type TypeB (line 7) | type TypeB struct
type TypeC (line 12) | type TypeC struct
type TypeD (line 18) | type TypeD struct
function build (line 22) | func build() *TypeA {
function Bar (line 30) | func Bar(s string) string {
function main (line 35) | func main() {
FILE: _test/issue-1010.go
type MyJsonMarshaler (line 8) | type MyJsonMarshaler struct
method MarshalJSON (line 10) | func (m MyJsonMarshaler) MarshalJSON() ([]byte, error) {
function main (line 14) | func main() {
FILE: _test/issue-1022.go
function main (line 5) | func main() {
FILE: _test/issue-1052.go
function main (line 5) | func main() {
FILE: _test/issue-1065.go
type AST (line 5) | type AST struct
function newAST (line 10) | func newAST(num int, root AST, children ...AST) AST {
function main (line 14) | func main() {
FILE: _test/issue-1068.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method Hello (line 9) | func (t T) Hello() { println("hello") }
type I2 (line 11) | type I2
function main (line 13) | func main() {
FILE: _test/issue-1088.go
function main (line 5) | func main() {
FILE: _test/issue-1089.go
function main (line 8) | func main() {
FILE: _test/issue-1093.go
function b (line 3) | func b() string {
function main (line 7) | func main() {
FILE: _test/issue-1094.go
function main (line 5) | func main() {
FILE: _test/issue-1101.go
function main (line 8) | func main() {
FILE: _test/issue-1115.go
function main (line 5) | func main() {
FILE: _test/issue-1126.go
function main (line 9) | func main() {
FILE: _test/issue-1128.go
function main (line 5) | func main() {
FILE: _test/issue-1134.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method Hello (line 12) | func (t *T) Hello() { println("Hello", t.Name) }
function main (line 14) | func main() {
FILE: _test/issue-1136.go
type T (line 8) | type T struct
method Read (line 12) | func (t *T) Read(p []byte) (n int, err error) { n, err = t.r.Read(p); ...
function main (line 14) | func main() {
FILE: _test/issue-1145.go
type F (line 5) | type F
function main (line 7) | func main() {
FILE: _test/issue-1156.go
type myInterface (line 3) | type myInterface interface
type V (line 7) | type V struct
method myFunc (line 9) | func (v *V) myFunc() string { return "hello" }
type U (line 11) | type U struct
method myFunc (line 15) | func (u *U) myFunc() string { return u.v.myFunc() }
function main (line 17) | func main() {
FILE: _test/issue-1163.go
type WidgetEvent (line 5) | type WidgetEvent struct
type WidgetControl (line 9) | type WidgetControl interface
type Button (line 13) | type Button struct
method HandleEvent (line 15) | func (b *Button) HandleEvent(e *WidgetEvent) {
type WindowEvent (line 18) | type WindowEvent struct
type Window (line 22) | type Window struct
method HandleEvent (line 26) | func (w *Window) HandleEvent(e *WindowEvent) {
function main (line 29) | func main() {
FILE: _test/issue-1166.go
type T (line 8) | type T
method Write (line 10) | func (t *T) Write(p []byte) (n int, err error) { *t = append(*t, p...)...
function foo (line 12) | func foo(w io.Writer) {
function main (line 18) | func main() {
FILE: _test/issue-1167.go
function main (line 9) | func main() {
FILE: _test/issue-1173.go
function main (line 5) | func main() {
FILE: _test/issue-1175.go
type Level (line 3) | type Level
constant a (line 6) | a Level = -1
constant b (line 7) | b Level = 5
constant d (line 8) | d = b - a + 1
type counters (line 11) | type counters
function main (line 13) | func main() {
FILE: _test/issue-1177.go
type counters (line 3) | type counters
function main (line 5) | func main() {
FILE: _test/issue-1179.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method F (line 11) | func (t *T) F() { println("in F", t.Name) }
function NewI (line 13) | func NewI(s string) I { return newT(s) }
function newT (line 15) | func newT(s string) *T { return &T{s} }
function main (line 17) | func main() {
FILE: _test/issue-1181.go
function main (line 3) | func main() {
FILE: _test/issue-1185.go
type B (line 5) | type B
method Write (line 7) | func (b B) Write(p []byte) (n int, err error) {
function main (line 12) | func main() {
FILE: _test/issue-1187.go
type sink (line 8) | type sink interface
function newSink (line 13) | func newSink() sink {
function main (line 22) | func main() {
FILE: _test/issue-1189.go
type I (line 3) | type I interface
type S1 (line 7) | type S1 struct
method Foo (line 11) | func (s S1) Foo() int { return s.i }
type S2 (line 13) | type S2 struct
method Foo (line 15) | func (s *S2) Foo() int { return 42 }
function main (line 17) | func main() {
FILE: _test/issue-1202.go
type foobar (line 5) | type foobar struct
function cb (line 9) | func cb(text string) func() {
function main (line 15) | func main() {
FILE: _test/issue-1205.go
type Option (line 3) | type Option interface
function f (line 7) | func f(opts ...Option) {
type T (line 13) | type T struct
method apply (line 15) | func (t *T) apply() { println("in apply") }
function main (line 17) | func main() {
FILE: _test/issue-1208.go
type Enabler (line 3) | type Enabler interface
type Logger (line 7) | type Logger struct
method GetCore (line 11) | func (log *Logger) GetCore() Enabler { return log.core }
type T (line 13) | type T struct
method Enabled (line 15) | func (t *T) Enabled() bool { return true }
function main (line 17) | func main() {
FILE: _test/issue-1260.go
type WriteSyncer (line 9) | type WriteSyncer interface
type Sink (line 14) | type Sink interface
function newFileSink (line 19) | func newFileSink(path string) (Sink, error) {
type Sink1 (line 23) | type Sink1 struct
method Write (line 25) | func (s Sink1) Write(b []byte) (int, error) { println("in Write"); ret...
method Sync (line 26) | func (s Sink1) Sync() error { println("in Sync"); retu...
method Close (line 27) | func (s Sink1) Close() error { println("in Close", s.na...
function newS1 (line 28) | func newS1(name string) Sink { return Sink1{name} }
function newS1p (line 29) | func newS1p(name string) Sink { return &Sink1{name} }
type Sink2 (line 31) | type Sink2 struct
method Write (line 33) | func (s *Sink2) Write(b []byte) (int, error) { println("in Write"); re...
method Sync (line 34) | func (s *Sink2) Sync() error { println("in Sync"); ret...
method Close (line 35) | func (s *Sink2) Close() error { println("in Close", s.n...
function newS2 (line 36) | func newS2(name string) Sink { return Sink1{name} }
function main (line 38) | func main() {
FILE: _test/issue-1276.go
type customFlag (line 7) | type customFlag struct
method String (line 9) | func (cf customFlag) String() string {
method Set (line 13) | func (cf customFlag) Set(string) error {
function main (line 17) | func main() {
FILE: _test/issue-1280.go
type DBReader (line 9) | type DBReader interface
type DB (line 14) | type DB struct
function main (line 18) | func main() {
FILE: _test/issue-1285.go
type T1 (line 4) | type T1 struct
type T2 (line 5) | type T2 struct
function main (line 13) | func main() {
FILE: _test/issue-1288.go
function main (line 3) | func main() {
FILE: _test/issue-1300.go
constant buflen (line 3) | buflen = 512
type T (line 5) | type T struct
function f (line 9) | func f(t *T) { *t = T{buf: make([]byte, 0, buflen)} }
function main (line 11) | func main() {
FILE: _test/issue-1304.go
type Node (line 3) | type Node struct
function main (line 9) | func main() {
FILE: _test/issue-1306.go
function check (line 5) | func check() (result bool, err error) {
function main (line 9) | func main() {
FILE: _test/issue-1308.go
type test (line 5) | type test struct
type T (line 10) | type T struct
function main (line 14) | func main() {
FILE: _test/issue-1311.go
type T (line 3) | type T struct
function f (line 7) | func f() (ret int64, err error) {
function main (line 12) | func main() {
FILE: _test/issue-1315.go
type Intf (line 3) | type Intf interface
type T (line 7) | type T struct
method M (line 11) | func (t *T) M() { println("in M") }
function f (line 13) | func f(i interface{}) {
function main (line 22) | func main() {
FILE: _test/issue-1320.go
type Pooler (line 3) | type Pooler interface
type baseClient (line 7) | type baseClient struct
type connPool (line 11) | type connPool struct
method Get (line 15) | func (c *connPool) Get() string { return c.name }
function newBaseClient (line 17) | func newBaseClient(i int, p Pooler) *baseClient {
function newConnPool (line 21) | func newConnPool() *connPool { return &connPool{name: "connPool"} }
function main (line 23) | func main() {
FILE: _test/issue-1326.go
type Option (line 3) | type Option interface
type T (line 7) | type T struct
type opt (line 11) | type opt struct
method apply (line 15) | func (o *opt) apply(t *T) {
function BuildOptions (line 19) | func BuildOptions() []Option {
function NewT (line 26) | func NewT(name string, options ...Option) *T {
function main (line 34) | func main() {
FILE: _test/issue-1328.go
function main (line 8) | func main() {
FILE: _test/issue-1330.go
type wrappedConn (line 9) | type wrappedConn struct
function main (line 13) | func main() {
FILE: _test/issue-1332.go
function run (line 3) | func run(fn func(name string)) { fn("test") }
type T2 (line 5) | type T2 struct
method f (line 9) | func (t *T2) f(s string) { println(s, t.name) }
function main (line 11) | func main() {
FILE: _test/issue-1333.go
function mock (line 10) | func mock(name string) http.HandlerFunc {
function client (line 16) | func client(uri string) {
function main (line 28) | func main() {
FILE: _test/issue-1337.go
function f (line 8) | func f(i interface{}) {
function main (line 18) | func main() {
FILE: _test/issue-1342.go
function main (line 5) | func main() {
FILE: _test/issue-1344.go
function main (line 5) | func main() {
FILE: _test/issue-1354.go
function main (line 3) | func main() {
function test (line 7) | func test() bool {
FILE: _test/issue-1355.go
function f (line 5) | func f(i interface{}) {
function main (line 10) | func main() {
FILE: _test/issue-1360.go
function main (line 8) | func main() {
FILE: _test/issue-1361.go
type obj (line 8) | type obj struct
type Fun (line 12) | type Fun
function numFun (line 14) | func numFun(fn func(f float64) float64) Fun {
function main (line 20) | func main() {
FILE: _test/issue-1364.go
function main (line 8) | func main() {
FILE: _test/issue-1365.go
function genInt (line 3) | func genInt() (int, error) { return 3, nil }
function getInt (line 5) | func getInt() (value int) {
function main (line 13) | func main() {
FILE: _test/issue-1368.go
constant dollar (line 3) | dollar byte = 36
function main (line 5) | func main() {
FILE: _test/issue-1371.go
type node (line 5) | type node struct
function main (line 11) | func main() {
FILE: _test/issue-1373.go
function NewBadExpr (line 8) | func NewBadExpr() ast.Expr {
function main (line 12) | func main() {
FILE: _test/issue-1375.go
type Option (line 5) | type Option
function WithOption (line 7) | func WithOption(opt string) Option {
type Struct (line 13) | type Struct struct
method ShowOption (line 25) | func (s *Struct) ShowOption() {
function New (line 17) | func New(opts ...Option) *Struct {
function main (line 29) | func main() {
FILE: _test/issue-1378.go
function main (line 8) | func main() {
FILE: _test/issue-1381.go
function main (line 8) | func main() {
FILE: _test/issue-1404.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method inI (line 11) | func (t *T) inI() {}
function main (line 13) | func main() {
FILE: _test/issue-1408.go
function f (line 8) | func f(n Number2) { println(n) }
function main (line 10) | func main() {
FILE: _test/issue-1411.go
type Number (line 3) | type Number
method IsValid (line 5) | func (n Number) IsValid() bool { return true }
function main (line 11) | func main() {
FILE: _test/issue-1416.go
type Number (line 3) | type Number
method IsValid (line 9) | func (n Number2) IsValid() bool { return true }
function main (line 11) | func main() {
FILE: _test/issue-1421.go
function main (line 5) | func main() {
FILE: _test/issue-1425.go
type WrappedReader (line 10) | type WrappedReader struct
method Read (line 14) | func (wr WrappedReader) Read(p []byte) (n int, err error) {
method WriteTo (line 21) | func (wr WrappedReader) WriteTo(w io.Writer) (n int64, err error) {
function main (line 31) | func main() {
FILE: _test/issue-1439.go
type Transformer (line 3) | type Transformer interface
type Encoder (line 7) | type Encoder struct
type nop (line 11) | type nop struct
method Reset (line 13) | func (nop) Reset() { println("Reset") }
function f (line 15) | func f(e Transformer) {
function main (line 19) | func main() {
FILE: _test/issue-1442.go
function main (line 7) | func main() {
FILE: _test/issue-1447.go
type I (line 5) | type I interface
type S (line 9) | type S struct
function main (line 13) | func main() {
FILE: _test/issue-1451.go
type t1 (line 3) | type t1
constant n1 (line 6) | n1 t1 = iota
constant n2 (line 7) | n2
type T (line 10) | type T struct
function main (line 14) | func main() {
FILE: _test/issue-1454.go
type I2 (line 3) | type I2 interface
type I (line 7) | type I interface
type S (line 11) | type S struct
method I2 (line 13) | func (*S) I2() string { return "foo" }
function main (line 15) | func main() {
FILE: _test/issue-1459.go
type funclistItem (line 5) | type funclistItem
type funclist (line 7) | type funclist struct
function main (line 11) | func main() {
FILE: _test/issue-1460.go
function unmarshalJSON (line 11) | func unmarshalJSON[T any](b []byte, x *[]T) error {
function SliceOfViews (line 21) | func SliceOfViews[T ViewCloner[T, V], V StructView[T]](x []T) SliceView[...
type StructView (line 25) | type StructView interface
type SliceView (line 30) | type SliceView struct
type ViewCloner (line 34) | type ViewCloner interface
method MarshalJSON (line 39) | func (v SliceView[T, V]) MarshalJSON() ([]byte, error) { return json.Mar...
method UnmarshalJSON (line 41) | func (v *SliceView[T, V]) UnmarshalJSON(b []byte) error { return unmarsh...
type Slice (line 43) | type Slice struct
method MarshalJSON (line 47) | func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v....
method UnmarshalJSON (line 49) | func (v *Slice[T]) UnmarshalJSON(b []byte) error { return unmarshalJSON(...
function SliceOf (line 51) | func SliceOf[T any](x []T) Slice[T] {
type IPPrefixSlice (line 55) | type IPPrefixSlice struct
type viewStruct (line 59) | type viewStruct struct
function main (line 65) | func main() {
FILE: _test/issue-1465.go
function SomeFunc (line 7) | func SomeFunc[T int | string](defaultValue T) T {
function main (line 17) | func main() {
FILE: _test/issue-1466.go
function SomeFunc (line 7) | func SomeFunc(defaultValue interface{}) interface{} {
function main (line 17) | func main() {
FILE: _test/issue-1470.go
type T (line 3) | type T struct
constant tnum (line 7) | tnum = 23
function main (line 9) | func main() {
FILE: _test/issue-1475.go
type T (line 3) | type T
function f (line 5) | func f() T { return 0 }
function main (line 7) | func main() {
FILE: _test/issue-1488.go
type vector (line 5) | type vector interface
function sum (line 9) | func sum[V vector](v V) (out int) {
function main (line 16) | func main() {
FILE: _test/issue-1496.go
function main (line 3) | func main() {
FILE: _test/issue-1515.go
type I1 (line 3) | type I1 interface
type I2 (line 8) | type I2 interface
type S2 (line 12) | type S2 struct
method Wrap (line 24) | func (s *S2) Wrap() *S3 {
function newS2 (line 16) | func newS2(i2 I2) I1 {
type S3 (line 20) | type S3 struct
type T (line 29) | type T struct
method F (line 33) | func (t *T) F() { println("in F", t.name) }
function main (line 35) | func main() {
FILE: _test/issue-1536.go
constant prefix (line 6) | prefix = "/usr/"
constant path (line 7) | path = prefix + "local/bin"
function main (line 10) | func main() {
FILE: _test/issue-1571.go
type A (line 3) | type A struct
type B (line 7) | type B struct
function main (line 11) | func main() {
FILE: _test/issue-1594.go
function main (line 3) | func main() {
FILE: _test/issue-1618.go
function humanizeBytes (line 9) | func humanizeBytes(bytes uint64) string {
function main (line 35) | func main() {
FILE: _test/issue-1640.go
function ShortVariableDeclarations (line 7) | func ShortVariableDeclarations() (i int, err error) {
function main (line 13) | func main() {
FILE: _test/issue-1653.go
function f (line 3) | func f(b uint) uint {
function main (line 7) | func main() {
FILE: _test/issue-435.go
type Foo (line 8) | type Foo
method String (line 10) | func (f Foo) String() string {
function print1 (line 14) | func print1(arg interface{}) {
function main (line 18) | func main() {
FILE: _test/issue-558.go
type readAutoCloser (line 10) | type readAutoCloser struct
method Read (line 14) | func (a readAutoCloser) Read(b []byte) (n int, err error) {
method Close (line 25) | func (a readAutoCloser) Close() error {
type pipe (line 32) | type pipe struct
function newReadAutoCloser (line 36) | func newReadAutoCloser(r io.Reader) readAutoCloser {
function main (line 43) | func main() {
FILE: _test/issue-735.go
function strToInt (line 12) | func strToInt(s string, defaultValue int) int {
function main (line 20) | func main() {
FILE: _test/issue-770.go
type I (line 5) | type I interface
type T (line 9) | type T struct
method Foo (line 13) | func (t T) Foo() int { return 0 }
function f (line 15) | func f(v reflect.Value) int {
function main (line 20) | func main() {
FILE: _test/issue-772.go
type Message (line 9) | type Message struct
function main (line 13) | func main() {
FILE: _test/issue-775.go
function main (line 8) | func main() {
FILE: _test/issue-776.go
type Filter (line 6) | type Filter interface
type GIFT (line 11) | type GIFT struct
method List (line 23) | func (g *GIFT) List() {
function New (line 16) | func New(filters ...Filter) *GIFT {
type MyFilter (line 28) | type MyFilter struct
method Foo (line 31) | func (f *MyFilter) Foo() {}
function main (line 33) | func main() {
FILE: _test/issue-782.go
function main (line 5) | func main() {
FILE: _test/issue-784.go
type Filter (line 6) | type Filter interface
type GIFT (line 11) | type GIFT struct
method Bounds (line 23) | func (g *GIFT) Bounds(srcBounds string) (dstBounds string) {
function New (line 16) | func New(filters ...Filter) *GIFT {
function main (line 31) | func main() {
FILE: _test/issue-880.go
function main (line 8) | func main() {
FILE: _test/issue-981.go
function main (line 5) | func main() {
FILE: _test/issue-993.go
function initVar (line 5) | func initVar() {
function main (line 9) | func main() {
FILE: _test/l2.go
function main (line 3) | func main() {
FILE: _test/l3.go
function main (line 5) | func main() {
FILE: _test/l4.go
function main (line 3) | func main() { println(f(5)) }
function f (line 4) | func f(i int) int { return i + 1 }
FILE: _test/l5.go
function main (line 5) | func main() {
FILE: _test/len0.go
function f (line 3) | func f(a []int) interface{} {
function main (line 7) | func main() {
FILE: _test/m1/main.go
function main (line 8) | func main() {
function TestWeird (line 12) | func TestWeird(t *testing.T) {
FILE: _test/m1/main_test.go
function TestMain (line 9) | func TestMain(t *testing.T) {
function BenchmarkMain (line 13) | func BenchmarkMain(b *testing.B) {
FILE: _test/m2/m2_test.go
function TestM2 (line 5) | func TestM2(t *testing.T) {
FILE: _test/make.go
function main (line 8) | func main() {
FILE: _test/make0.go
function f (line 3) | func f() interface{} {
function main (line 7) | func main() {
FILE: _test/make1.go
function f (line 5) | func f() interface{} {
function main (line 9) | func main() {
FILE: _test/make2.go
function main (line 5) | func main() {
FILE: _test/map.go
type Dict (line 3) | type Dict
function main (line 5) | func main() {
FILE: _test/map10.go
type Foo (line 8) | type Foo struct
function main (line 12) | func main() {
FILE: _test/map11.go
type Foo (line 8) | type Foo struct
function main (line 12) | func main() {
FILE: _test/map12.go
type Foo (line 8) | type Foo struct
function main (line 12) | func main() {
FILE: _test/map13.go
constant acceptEncoding (line 8) | acceptEncoding = "Accept-Encoding"
function main (line 10) | func main() {
FILE: _test/map14.go
function f (line 7) | func f(s string) bool { return m[s] > 0.0 }
function main (line 9) | func main() {
FILE: _test/map15.go
function main (line 5) | func main() {
FILE: _test/map16.go
function main (line 5) | func main() {
FILE: _test/map17.go
type T (line 5) | type T struct
method ServeHTTP (line 9) | func (b *T) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
function main (line 15) | func main() {
FILE: _test/map18.go
function main (line 7) | func main() {
FILE: _test/map19.go
type cmap (line 5) | type cmap struct
type server (line 9) | type server struct
function main (line 13) | func main() {
FILE: _test/map2.go
function main (line 3) | func main() {
FILE: _test/map20.go
function main (line 5) | func main() {
FILE: _test/map21.go
function main (line 7) | func main() {
FILE: _test/map22.go
function main (line 7) | func main() {
FILE: _test/map23.go
function main (line 7) | func main() {
FILE: _test/map24.go
function main (line 8) | func main() {
FILE: _test/map25.go
function main (line 8) | func main() {
FILE: _test/map26.go
function main (line 5) | func main() {
FILE: _test/map27.go
type fm (line 8) | type fm
type foo (line 10) | type foo struct
function main (line 12) | func main() {
FILE: _test/map28.go
function main (line 7) | func main() {
FILE: _test/map29.go
type Item (line 8) | type Item struct
function main (line 13) | func main() {
FILE: _test/map3.go
function main (line 3) | func main() {
FILE: _test/map30.go
function f (line 5) | func f(s string) string { return "hello " + s }
function g (line 7) | func g(s string) string { return "hi " + s }
function main (line 14) | func main() {
FILE: _test/map31.go
function main (line 3) | func main() {
FILE: _test/map4.go
function main (line 3) | func main() {
FILE: _test/map5.go
function main (line 5) | func main() {
FILE: _test/map6.go
function main (line 3) | func main() {
FILE: _test/map7.go
function main (line 3) | func main() {
FILE: _test/map8.go
function main (line 8) | func main() {
FILE: _test/map9.go
type Foo (line 8) | type Foo struct
function main (line 12) | func main() {
FILE: _test/math0.go
function main (line 8) | func main() {
FILE: _test/math1.go
function main (line 5) | func main() {
FILE: _test/math2.go
constant c (line 3) | c uint64 = 2
function main (line 5) | func main() {
FILE: _test/math3.go
function md5Crypt (line 8) | func md5Crypt(password, salt, magic []byte) []byte {
function main (line 25) | func main() {
FILE: _test/method.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
function main (line 9) | func main() {
FILE: _test/method0.go
type Foo (line 5) | type Foo struct
method Call (line 8) | func (Foo) Call() {
type Bar (line 12) | type Bar struct
type Baz (line 16) | type Baz struct
method Call (line 20) | func (Baz) Call() {
function main (line 24) | func main() {
FILE: _test/method1.go
type Sample (line 3) | type Sample struct
method foo (line 7) | func (s *Sample) foo(i int) {
function main (line 11) | func main() {
FILE: _test/method10.go
constant BlockSize (line 3) | BlockSize = 8
type Cipher (line 5) | type Cipher struct
method BlockSize (line 7) | func (c *Cipher) BlockSize() int { return BlockSize }
function main (line 9) | func main() {
FILE: _test/method11.go
function BlockSize (line 3) | func BlockSize() string { return "func" }
type Cipher (line 5) | type Cipher struct
method BlockSize (line 7) | func (c *Cipher) BlockSize() string { return "method" }
function main (line 9) | func main() {
FILE: _test/method12.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
function main (line 9) | func main() {
FILE: _test/method13.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
type Point (line 9) | type Point struct
function main (line 14) | func main() {
FILE: _test/method14.go
function main (line 3) | func main() {
type Coord (line 10) | type Coord struct
method dist (line 8) | func (c *Coord) dist() int { return c.x*c.x + c.y*c.y }
FILE: _test/method15.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
function main (line 9) | func main() {
FILE: _test/method16.go
type Cheese (line 7) | type Cheese struct
method Hello (line 11) | func (t *Cheese) Hello(param string) {
function main (line 15) | func main() {
FILE: _test/method17.go
type MyTime (line 8) | type MyTime struct
method Foo (line 13) | func (m MyTime) Foo() {
method Bar (line 18) | func (m *MyTime) Bar() {
function main (line 23) | func main() {
FILE: _test/method18.go
type GzipResponseWriter (line 9) | type GzipResponseWriter struct
type GzipResponseWriterWithCloseNotify (line 15) | type GzipResponseWriterWithCloseNotify struct
method CloseNotify (line 19) | func (w GzipResponseWriterWithCloseNotify) CloseNotify() <-chan bool {
function main (line 23) | func main() {
FILE: _test/method19.go
function f (line 5) | func f() (string, error) {
function main (line 10) | func main() {
FILE: _test/method2.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
type Point (line 9) | type Point struct
function main (line 14) | func main() {
FILE: _test/method20.go
type Hello (line 8) | type Hello struct
method Hi (line 12) | func (h *Hello) Hi() string {
function main (line 18) | func main() {
FILE: _test/method21.go
type Hello (line 7) | type Hello struct
method Hi (line 9) | func (*Hello) Hi() string {
function main (line 13) | func main() {
FILE: _test/method22.go
function Bar (line 3) | func Bar() {
type T (line 10) | type T struct
method Foo (line 12) | func (t *T) Foo() bool { return t != nil }
function main (line 14) | func main() {
FILE: _test/method23.go
function Bar (line 3) | func Bar() {
function NewT (line 10) | func NewT() *T { return &T{} }
type T (line 12) | type T struct
method Foo (line 14) | func (t *T) Foo() bool { return t != nil }
function main (line 16) | func main() {
FILE: _test/method24.go
type Pool (line 8) | type Pool struct
method Get (line 12) | func (p Pool) Get() *Buffer { return &Buffer{} }
function NewPool (line 14) | func NewPool() Pool { return Pool{} }
type Buffer (line 16) | type Buffer struct
function main (line 26) | func main() {
FILE: _test/method25.go
function NewPool (line 10) | func NewPool() Pool { return Pool{} }
type Buffer (line 12) | type Buffer struct
type Pool (line 17) | type Pool struct
method Get (line 8) | func (p Pool) Get() *Buffer { return &Buffer{} }
function main (line 26) | func main() {
FILE: _test/method26.go
function NewT (line 3) | func NewT(name string) *T { return &T{name} }
type T (line 9) | type T struct
method f (line 7) | func (t *T) f() { println(t == C) }
function main (line 13) | func main() {
FILE: _test/method27.go
type AuthenticatedRequest (line 8) | type AuthenticatedRequest struct
function main (line 13) | func main() {
FILE: _test/method28.go
type T (line 5) | type T struct
method create (line 9) | func (T) create() *T {
function main (line 13) | func main() {
FILE: _test/method29.go
function main (line 10) | func main() {
FILE: _test/method3.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
type Point (line 9) | type Point struct
function main (line 14) | func main() {
FILE: _test/method30.go
type T (line 3) | type T struct
method foo (line 7) | func (t *T) foo(a string) string {
function main (line 15) | func main() {
FILE: _test/method31.go
type dbWrapper (line 7) | type dbWrapper struct
method get (line 11) | func (d *dbWrapper) get() *cmap {
type cmap (line 15) | type cmap struct
method f (line 19) | func (c *cmap) f() {
function main (line 23) | func main() {
FILE: _test/method32.go
function main (line 7) | func main() {
function bar (line 13) | func bar(a string) {
FILE: _test/method33.go
type T1 (line 7) | type T1 struct
method f (line 9) | func (t1 T1) f() {
method g (line 13) | func (t1 T1) g() {
type T2 (line 17) | type T2 struct
method f (line 21) | func (t2 T2) f() {
type I (line 25) | type I interface
function printType (line 29) | func printType(i I) {
function main (line 43) | func main() {
FILE: _test/method34.go
type Root (line 3) | type Root struct
method Hello (line 19) | func (r *Root) Hello() string { return "Hello " + r.Name }
type One (line 7) | type One struct
type Hi (line 11) | type Hi interface
type Hey (line 15) | type Hey interface
function main (line 21) | func main() {
FILE: _test/method35.go
function main (line 5) | func main() {
FILE: _test/method36.go
type I (line 3) | type I interface
type T (line 5) | type T struct
method Hello (line 7) | func (t *T) Hello() { println("Hello", t.Name) }
type FT (line 9) | type FT
type ST (line 11) | type ST struct
function newF (line 13) | func newF() FT {
function main (line 19) | func main() {
FILE: _test/method37.go
function writeBufs (line 8) | func writeBufs(bufs ...[]byte) error {
function main (line 14) | func main() {
FILE: _test/method38.go
function main (line 9) | func main() {
FILE: _test/method38/a.go
function NewPool (line 5) | func NewPool() Pool { return Pool{} }
type Buffer (line 7) | type Buffer struct
type Pool (line 12) | type Pool struct
FILE: _test/method38/b.go
method Get (line 3) | func (p Pool) Get() *Buffer { return &Buffer{} }
FILE: _test/method39.go
function NewPool (line 10) | func NewPool() Pool { return Pool{} }
type Buffer (line 12) | type Buffer struct
type Pool (line 17) | type Pool struct
function main (line 27) | func main() {
FILE: _test/method4.go
type Coord (line 3) | type Coord struct
method dist (line 7) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
type Point (line 9) | type Point struct
type Tpoint (line 14) | type Tpoint struct
function main (line 19) | func main() {
FILE: _test/method40.go
type TMemoryBuffer (line 8) | type TMemoryBuffer struct
function newTMemoryBuffer (line 13) | func newTMemoryBuffer() *TMemoryBuffer {
type TTransport (line 19) | type TTransport interface
function check (line 23) | func check(t TTransport) {
function main (line 27) | func main() {
FILE: _test/method5.go
type Foo (line 5) | type Foo struct
method Show (line 8) | func (Foo) Show() {
method Call (line 12) | func (f Foo) Call() {
type Bar (line 17) | type Bar struct
type Baz (line 21) | type Baz struct
method Call (line 25) | func (Baz) Call() {
method Show (line 29) | func (Baz) Show() {
function main (line 33) | func main() {
FILE: _test/method6.go
type Sample (line 3) | type Sample struct
method foo (line 7) | func (s Sample) foo(i int) {
function main (line 15) | func main() {
FILE: _test/method7.go
type Sample (line 3) | type Sample struct
method foo (line 7) | func (s *Sample) foo(i int) {
function main (line 15) | func main() {
FILE: _test/method8.go
type Sample (line 3) | type Sample struct
method foo (line 8) | func (s *Sample) foo(j int) {
function main (line 18) | func main() {
FILE: _test/method9.go
type Coord (line 3) | type Coord struct
method dist (line 12) | func (c Coord) dist() int { return c.x*c.x + c.y*c.y }
function main (line 7) | func main() {
FILE: _test/named0.go
type Root (line 5) | type Root struct
method Hello (line 9) | func (r *Root) Hello() {
function main (line 15) | func main() {
function displayOne (line 25) | func displayOne(val *One) {
function displayRoot (line 29) | func displayRoot(val *Root) {
FILE: _test/named1.go
type MyT (line 5) | type MyT
type T (line 7) | type T struct
function main (line 11) | func main() {
FILE: _test/named2.go
type MyT (line 9) | type MyT
method Test (line 5) | func (t MyT) Test() string {
function main (line 11) | func main() {
FILE: _test/named3.go
function init (line 7) | func init() {
type T (line 11) | type T
method PrintT (line 13) | func (t *T) PrintT() {
function main (line 17) | func main() {
FILE: _test/named3/named3.go
type T (line 8) | type T struct
method Print (line 12) | func (t *T) Print() {
type A (line 16) | type A
method ForeachKey (line 18) | func (a A) ForeachKey() error {
method Set (line 29) | func (a A) Set(k string, v []string) {
FILE: _test/named4.go
type A (line 8) | type A
method Test1 (line 10) | func (a A) Test1() {
type B (line 14) | type B
method Test2 (line 16) | func (b B) Test2() {
method Test3 (line 20) | func (b B) Test3() {
function main (line 28) | func main() {
FILE: _test/neg0.go
function main (line 5) | func main() {
FILE: _test/new0.go
function main (line 3) | func main() {
FILE: _test/new1.go
function main (line 5) | func main() {
FILE: _test/new2.go
function f (line 3) | func f() interface{} {
function main (line 7) | func main() {
FILE: _test/nil0.go
function f (line 5) | func f() (host, port string, err error) {
function main (line 9) | func main() {
FILE: _test/nil1.go
function main (line 3) | func main() {
FILE: _test/nil2.go
function test (line 3) | func test() error { return nil }
function main (line 5) | func main() {
FILE: _test/nil3.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method Hello (line 11) | func (t *T) Hello() { println("Hello") }
function main (line 13) | func main() {
FILE: _test/not0.go
function main (line 3) | func main() {
FILE: _test/not1.go
function main (line 3) | func main() {
FILE: _test/not2.go
function main (line 3) | func main() {
FILE: _test/num0.go
function main (line 5) | func main() {
FILE: _test/op0.go
function main (line 5) | func main() {
FILE: _test/op1.go
function main (line 3) | func main() {
FILE: _test/op10.go
function main (line 3) | func main() {
FILE: _test/op11.go
function main (line 3) | func main() {
FILE: _test/op2.go
function main (line 5) | func main() {
FILE: _test/op3.go
function main (line 5) | func main() {
FILE: _test/op4.go
function main (line 3) | func main() {
FILE: _test/op5.go
function main (line 5) | func main() {
FILE: _test/op6.go
type T (line 3) | type T
method Error (line 5) | func (t T) Error() string { return "T: error" }
function main (line 9) | func main() {
FILE: _test/op7.go
type T (line 3) | type T
method Error (line 5) | func (t T) Error() string { return "T: error" }
function main (line 9) | func main() {
FILE: _test/op8.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method Get (line 9) | func (T) Get() interface{} {
function main (line 13) | func main() {
FILE: _test/op9.go
function main (line 3) | func main() {
FILE: _test/opfloat32.go
function main (line 5) | func main() {
FILE: _test/opfloat64.go
function main (line 5) | func main() {
FILE: _test/opint16.go
function main (line 5) | func main() {
FILE: _test/opint32.go
function main (line 5) | func main() {
FILE: _test/opint64.go
function main (line 5) | func main() {
FILE: _test/opint8.go
function main (line 5) | func main() {
FILE: _test/opstring.go
function main (line 5) | func main() {
FILE: _test/opuint16.go
function main (line 5) | func main() {
FILE: _test/opuint32.go
function main (line 5) | func main() {
FILE: _test/opuint64.go
function main (line 5) | func main() {
FILE: _test/opuint8.go
function main (line 5) | func main() {
FILE: _test/or0.go
function main (line 3) | func main() {
FILE: _test/or1.go
function main (line 3) | func main() {
FILE: _test/or2.go
function main (line 5) | func main() {
FILE: _test/os0.go
function main (line 8) | func main() {
FILE: _test/p1/s2.go
function init (line 7) | func init() { rand.Seed(1) }
FILE: _test/p2/p2.go
type I (line 3) | type I interface
type T (line 7) | type T struct
method isI (line 9) | func (t *T) isI() {}
FILE: _test/p5.go
function main (line 5) | func main() {
FILE: _test/p6.go
function main (line 9) | func main() {
FILE: _test/p6/p6.go
type Slice (line 8) | type Slice struct
type IPPrefixSlice (line 12) | type IPPrefixSlice struct
method MarshalJSON (line 19) | func (v IPPrefixSlice) MarshalJSON() ([]byte, error) {
method MarshalJSON (line 16) | func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v....
FILE: _test/panic0.go
function main (line 3) | func main() {
function foo (line 7) | func foo() {
function bar (line 11) | func bar() {
function baz (line 15) | func baz() {
FILE: _test/pkgname0.go
function main (line 8) | func main() {
FILE: _test/pkgname1.go
function main (line 7) | func main() {
FILE: _test/pkgname2.go
function main (line 7) | func main() {
FILE: _test/primes.go
function Primes (line 3) | func Primes(n int) int {
function main (line 21) | func main() {
FILE: _test/print0.go
function main (line 3) | func main() {
FILE: _test/ptr0.go
type myint (line 3) | type myint
function main (line 5) | func main() {
FILE: _test/ptr1.go
function main (line 3) | func main() {
FILE: _test/ptr2.go
function f (line 3) | func f(i *int) {
function main (line 7) | func main() {
FILE: _test/ptr3.go
function f (line 3) | func f(i *int) {
function main (line 7) | func main() {
FILE: _test/ptr4.go
type Foo (line 3) | type Foo struct
function f (line 7) | func f(p *Foo) {
function main (line 11) | func main() {
FILE: _test/ptr5.go
type Foo (line 3) | type Foo struct
function main (line 7) | func main() {
FILE: _test/ptr5a.go
type Foo (line 3) | type Foo struct
function main (line 7) | func main() {
FILE: _test/ptr6.go
type Foo (line 3) | type Foo struct
function main (line 7) | func main() {
FILE: _test/ptr7.go
type ipNetValue (line 9) | type ipNetValue
method Set (line 11) | func (ipnet *ipNetValue) Set(value string) error {
function main (line 20) | func main() {
FILE: _test/ptr8.go
function main (line 5) | func main() {
FILE: _test/ptr_array0.go
type T (line 3) | type T
function F0 (line 5) | func F0(t *T) int { return t[0] }
function main (line 7) | func main() {
FILE: _test/ptr_array1.go
type T (line 3) | type T
function F0 (line 5) | func F0(t *T) {
function main (line 11) | func main() {
FILE: _test/ptr_array2.go
type T (line 5) | type T
function F1 (line 7) | func F1(t *T) { t[0] = 1 }
function main (line 9) | func main() {
FILE: _test/ptr_array3.go
function main (line 5) | func main() {
FILE: _test/range0.go
function main (line 5) | func main() {
FILE: _test/range1.go
function main (line 5) | func main() {
FILE: _test/range2.go
function main (line 5) | func main() {
FILE: _test/range3.go
function main (line 5) | func main() {
FILE: _test/range4.go
function main (line 5) | func main() {
FILE: _test/range5.go
function main (line 5) | func main() {
FILE: _test/range6.go
function main (line 8) | func main() {
FILE: _test/range7.go
function someChan (line 7) | func someChan() <-chan struct{} {
function main (line 13) | func main() {
FILE: _test/range8.go
function main (line 8) | func main() {
FILE: _test/range9.go
function main (line 3) | func main() {
FILE: _test/real0.go
function f (line 5) | func f(c complex128) interface{} { return real(c) }
function main (line 7) | func main() {
FILE: _test/recover0.go
function main (line 5) | func main() {
FILE: _test/recover1.go
function main (line 5) | func main() {
FILE: _test/recover2.go
function main (line 3) | func main() {
FILE: _test/recover3.go
function main (line 5) | func main() {
FILE: _test/recover4.go
function div (line 5) | func div(a, b int) (result int) {
function main (line 19) | func main() {
FILE: _test/recurse0.go
type T (line 5) | type T struct
type U (line 18) | type U struct
function main (line 30) | func main() {
FILE: _test/recurse1.go
type F (line 3) | type F
type A (line 5) | type A struct
function main (line 10) | func main() {
FILE: _test/recurse2.go
type F (line 3) | type F
type A (line 5) | type A struct
type D (line 11) | type D struct
function f1 (line 16) | func f1(a *A) { println("in f1", a.B) }
function main (line 18) | func main() {
FILE: _test/recurse3.go
type F (line 3) | type F
type A (line 5) | type A struct
type D (line 10) | type D struct
function f1 (line 16) | func f1(a *A) { println("in f1", a.B) }
function main (line 18) | func main() {
FILE: _test/redeclaration-global0.go
type time (line 3) | type time
function main (line 7) | func main() {
FILE: _test/redeclaration-global1.go
type time (line 5) | type time
function main (line 7) | func main() {
FILE: _test/redeclaration-global2.go
function main (line 8) | func main() {
FILE: _test/redeclaration-global3.go
function main (line 9) | func main() {
FILE: _test/redeclaration-global4.go
type time (line 7) | type time
function main (line 9) | func main() {
FILE: _test/redeclaration-global5.go
function time (line 5) | func time() string {
function main (line 9) | func main() {
FILE: _test/redeclaration-global6.go
function time (line 7) | func time() string {
function main (line 11) | func main() {
FILE: _test/redeclaration-global7.go
function main (line 8) | func main() {
FILE: _test/redeclaration0.go
function main (line 3) | func main() {
FILE: _test/redeclaration1.go
function main (line 3) | func main() {
FILE: _test/redeclaration2.go
function main (line 3) | func main() {
FILE: _test/redeclaration3.go
function main (line 3) | func main() {
FILE: _test/redeclaration4.go
function main (line 3) | func main() {
FILE: _test/redeclaration5.go
function main (line 3) | func main() {
FILE: _test/restricted0.go
function main (line 8) | func main() {
FILE: _test/restricted1.go
function main (line 8) | func main() {
FILE: _test/restricted2.go
function main (line 8) | func main() {
FILE: _test/restricted3.go
function main (line 14) | func main() {
FILE: _test/ret1.go
function f (line 3) | func f(i int) (o int) { o = i + 1; return }
function main (line 5) | func main() { println(f(4)) }
FILE: _test/ret2.go
function r2 (line 3) | func r2() (int, int) { return 1, 2 }
function main (line 5) | func main() {
FILE: _test/ret3.go
function r2 (line 5) | func r2() (int, int) { return 1, 2 }
function main (line 7) | func main() {
FILE: _test/ret4.go
function r (line 3) | func r() int { return 1 }
function main (line 5) | func main() {
FILE: _test/ret5.go
function r2 (line 3) | func r2() (int, int) { return 1, 2 }
function main (line 7) | func main() { println(a, b) }
FILE: _test/ret6.go
type Foo (line 5) | type Foo struct
function foo (line 7) | func foo() *Foo { return nil }
function main (line 9) | func main() {
FILE: _test/ret7.go
function one (line 3) | func one() uint {
function main (line 6) | func main() {
FILE: _test/ret8.go
type CustomError (line 5) | type CustomError
method Error (line 7) | func (s CustomError) Error() string {
function NewCustomError (line 11) | func NewCustomError(errorText string) CustomError {
function fail (line 15) | func fail() (err error) {
function main (line 19) | func main() {
FILE: _test/run0.go
function f (line 5) | func f() (int, int) { return 2, 3 }
function main (line 7) | func main() {
FILE: _test/run1.go
function f (line 3) | func f() (int, int) { return 2, 3 }
function g (line 5) | func g(i, j int) int { return i + j }
function main (line 7) | func main() {
FILE: _test/run10.go
function main (line 3) | func main() {
FILE: _test/run11.go
function main (line 5) | func main() {
function f (line 9) | func f() (int, int) { return 2, 3 }
FILE: _test/run12.go
function f (line 3) | func f(a int) (int, int) {
function main (line 7) | func main() {
FILE: _test/run13.go
function main (line 3) | func main() {
function f (line 8) | func f(a int) (int, int) {
FILE: _test/run4.go
type fn (line 3) | type fn
function f1 (line 5) | func f1(i int) { println("f1", i) }
function test (line 7) | func test(f fn, v int) { f(v) }
function main (line 9) | func main() { test(f1, 21) }
FILE: _test/run5.go
type fn (line 3) | type fn
function test (line 5) | func test(f fn, v int) { f(v) }
function main (line 7) | func main() {
FILE: _test/run6.go
type fn (line 3) | type fn
function test (line 5) | func test(f fn, v int) { f(v) }
function main (line 7) | func main() {
FILE: _test/run7.go
type fn (line 3) | type fn
function test (line 5) | func test(f fn, v int) { f(v) }
function main (line 7) | func main() {
FILE: _test/run8.go
function main (line 3) | func main() {
FILE: _test/run9.go
function main (line 3) | func main() {
FILE: _test/rune0.go
function main (line 5) | func main() {
FILE: _test/rune1.go
function main (line 5) | func main() {
FILE: _test/rune2.go
constant majorVersion (line 5) | majorVersion = '2'
type hashed (line 7) | type hashed struct
function main (line 11) | func main() {
FILE: _test/scope0.go
function main (line 5) | func main() {
FILE: _test/scope1.go
function f (line 3) | func f(a int) int {
function main (line 9) | func main() {
FILE: _test/scope2.go
function f (line 5) | func f() { println(a) }
function main (line 7) | func main() {
FILE: _test/scope3.go
function main (line 3) | func main() {
FILE: _test/scope4.go
function main (line 3) | func main() {
FILE: _test/scope5.go
function f (line 5) | func f() { println(a) }
function main (line 7) | func main() {
FILE: _test/scope6.go
function f (line 7) | func f() { fmt.Println(a) }
function main (line 9) | func main() {
FILE: _test/scope7.go
function f (line 7) | func f() { fmt.Println(a) }
function main (line 9) | func main() {
FILE: _test/select.go
function main (line 6) | func main() {
FILE: _test/select0.go
function forever (line 5) | func forever() {
function main (line 10) | func main() {
FILE: _test/select1.go
function main (line 8) | func main() {
FILE: _test/select10.go
function main (line 3) | func main() {
FILE: _test/select11.go
function main (line 3) | func main() {
FILE: _test/select12.go
type S (line 3) | type S struct
method Send (line 7) | func (s *S) Send() {
function main (line 15) | func main() {
FILE: _test/select13.go
function main (line 3) | func main() {
FILE: _test/select14.go
constant period (line 9) | period = 300 * time.Millisecond
constant precision (line 10) | precision = 30 * time.Millisecond
function main (line 13) | func main() {
FILE: _test/select15.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/select2.go
function main (line 7) | func main() {
FILE: _test/select3.go
function main (line 3) | func main() {
FILE: _test/select4.go
function main (line 3) | func main() {
FILE: _test/select5.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/select6.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/select7.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/select8.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/select9.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/selector-scope0.go
function test (line 8) | func test(time string, t time.Time) string {
function test2 (line 14) | func test2(time string) time.Time {
function main (line 18) | func main() {
FILE: _test/server.go
function main (line 10) | func main() {
FILE: _test/server0.go
function myHandler (line 10) | func myHandler(w http.ResponseWriter, r *http.Request) {
function main (line 14) | func main() {
FILE: _test/server1.go
type Middleware (line 10) | type Middleware struct
method Handler (line 14) | func (m *Middleware) Handler(w http.ResponseWriter, r *http.Request) {
function main (line 18) | func main() {
FILE: _test/server1a.go
type Middleware (line 11) | type Middleware struct
method Handler (line 15) | func (m *Middleware) Handler(w http.ResponseWriter, r *http.Request) {
function main (line 22) | func main() {
FILE: _test/server2.go
function main (line 10) | func main() {
FILE: _test/server3.go
function main (line 9) | func main() {
FILE: _test/server4.go
function main (line 7) | func main() {
FILE: _test/server5.go
function main (line 11) | func main() {
FILE: _test/server6.go
type T1 (line 12) | type T1 struct
method Handler (line 16) | func (t *T1) Handler(h http.Handler) http.Handler {
function main (line 24) | func main() {
FILE: _test/server7.go
function main (line 7) | func main() {
FILE: _test/shift0.go
function main (line 3) | func main() {
FILE: _test/shift1.go
constant a1 (line 5) | a1 = 0x7f8 >> 3
function main (line 7) | func main() {
FILE: _test/shift2.go
function main (line 3) | func main() {
FILE: _test/shift3.go
constant a (line 3) | a = 1.0
constant b (line 5) | b = a + 3
function main (line 7) | func main() { println(b << (1)) }
FILE: _test/sieve.go
function Generate (line 6) | func Generate(ch chan<- int) {
function Filter (line 14) | func Filter(in <-chan int, out chan<- int, prime int) {
function main (line 24) | func main() {
FILE: _test/slice.go
function main (line 5) | func main() {
FILE: _test/str.go
function main (line 3) | func main() {
FILE: _test/str0.go
constant itoa64 (line 5) | itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
function main (line 7) | func main() {
FILE: _test/str1.go
constant itoa64 (line 3) | itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
function main (line 5) | func main() {
FILE: _test/str2.go
constant itoa64 (line 3) | itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
function main (line 5) | func main() {
FILE: _test/str3.go
function main (line 5) | func main() {
FILE: _test/str4.go
function main (line 5) | func main() {
FILE: _test/struct.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/struct0.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/struct0a.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/struct1.go
type T (line 3) | type T struct
function main (line 10) | func main() {
FILE: _test/struct10.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/struct11.go
type Fromage (line 8) | type Fromage struct
function main (line 12) | func main() {
FILE: _test/struct12.go
type S1 (line 5) | type S1 struct
type S2 (line 9) | type S2 struct
function main (line 13) | func main() {
FILE: _test/struct13.go
type Fromage (line 8) | type Fromage struct
function main (line 12) | func main() {
FILE: _test/struct14.go
type Fromage (line 8) | type Fromage struct
function main (line 12) | func main() {
FILE: _test/struct15.go
type GzipResponseWriter (line 8) | type GzipResponseWriter struct
type GzipResponseWriterWithCloseNotify (line 13) | type GzipResponseWriterWithCloseNotify struct
method CloseNotify (line 17) | func (w GzipResponseWriterWithCloseNotify) CloseNotify() <-chan bool {
function main (line 21) | func main() {
FILE: _test/struct16.go
type S1 (line 3) | type S1 struct
type S2 (line 7) | type S2 struct
function main (line 11) | func main() {
FILE: _test/struct17.go
type S1 (line 3) | type S1 struct
type S2 (line 7) | type S2 struct
function main (line 11) | func main() {
FILE: _test/struct18.go
type AuthenticatedRequest (line 8) | type AuthenticatedRequest struct
function main (line 13) | func main() {
FILE: _test/struct19.go
type Config (line 5) | type Config struct
type Users (line 14) | type Users
function CreateConfig (line 16) | func CreateConfig() *Config {
function main (line 20) | func main() {
FILE: _test/struct2.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/struct20.go
type SecretProvider (line 3) | type SecretProvider
type BasicAuth (line 5) | type BasicAuth struct
method CheckAuth (line 10) | func (a *BasicAuth) CheckAuth() string { return a.Secrets("me", a.Real...
function secretBasic (line 12) | func secretBasic(user, realm string) string { return user + "-" + realm }
function main (line 14) | func main() {
FILE: _test/struct21.go
type SecretProvider (line 3) | type SecretProvider
type BasicAuth (line 5) | type BasicAuth struct
method CheckAuth (line 10) | func (a *BasicAuth) CheckAuth() string { return a.Secrets("me", a.Real...
method secretBasic (line 12) | func (a *BasicAuth) secretBasic(user, realm string) string { return a....
function main (line 14) | func main() {
FILE: _test/struct22.go
type S (line 3) | type S struct
function main (line 8) | func main() {
FILE: _test/struct23.go
type S (line 8) | type S struct
function main (line 13) | func main() {
FILE: _test/struct24.go
type T (line 5) | type T struct
function main (line 7) | func main() {
FILE: _test/struct25.go
type T (line 7) | type T struct
function main (line 9) | func main() {
FILE: _test/struct26.go
function newT2 (line 5) | func newT2() *T2 { return &T2{} }
type T2 (line 7) | type T2 struct
type T1 (line 11) | type T1 struct
function main (line 15) | func main() {
FILE: _test/struct27.go
type Foo (line 7) | type Foo struct
method Boo (line 5) | func (f *Foo) Boo() { fmt.Println(f.name, "Boo") }
function main (line 12) | func main() {
FILE: _test/struct28.go
type T1 (line 5) | type T1 struct
type T2 (line 9) | type T2 struct
function main (line 13) | func main() {
FILE: _test/struct29.go
type T1 (line 3) | type T1 struct
type T2 (line 8) | type T2 struct
function main (line 14) | func main() {
FILE: _test/struct3.go
type T (line 3) | type T struct
function f (line 11) | func f(i int) int { return i + 3 }
function main (line 13) | func main() {
FILE: _test/struct30.go
type T1 (line 3) | type T1 struct
type T2 (line 8) | type T2 struct
function main (line 14) | func main() {
FILE: _test/struct31.go
type T (line 3) | type T struct
function main (line 9) | func main() {
FILE: _test/struct32.go
type T0 (line 3) | type T0 struct
method F1 (line 14) | func (t T0) F1() bool { println("in F1"); return true }
type lookupFunc (line 7) | type lookupFunc
type T1 (line 9) | type T1 struct
type T2 (line 16) | type T2 struct
method f (line 20) | func (t2 *T2) f() {
function main (line 27) | func main() {
FILE: _test/struct33.go
type T0 (line 3) | type T0 struct
method F1 (line 14) | func (t T0) F1() bool { println("in F1"); return true }
type lookupFunc (line 7) | type lookupFunc
type T1 (line 9) | type T1 struct
function look (line 18) | func look(s string) T0 { println("in look"); return t0 }
function main (line 26) | func main() {
FILE: _test/struct34.go
type T (line 3) | type T struct
function f1 (line 7) | func f1(t *T) { t.f = f2 }
function f2 (line 9) | func f2(t *T) { t.f = f1 }
function main (line 11) | func main() {
FILE: _test/struct35.go
type T (line 3) | type T struct
function f1 (line 7) | func f1(t *T) { t.f = f1 }
function main (line 9) | func main() {
FILE: _test/struct36.go
type S (line 8) | type S struct
function main (line 12) | func main() {
FILE: _test/struct37.go
type MyHttpClient (line 8) | type MyHttpClient struct
function main (line 12) | func main() {
FILE: _test/struct38.go
type T (line 3) | type T struct
type T1 (line 8) | type T1 struct
type xxx (line 12) | type xxx struct
function main (line 19) | func main() {
FILE: _test/struct39.go
type T (line 3) | type T struct
type T1 (line 8) | type T1 struct
type xxx (line 15) | type xxx struct
function main (line 17) | func main() {
FILE: _test/struct4.go
type T3 (line 3) | type T3 struct
type T2 (line 7) | type T2 struct
type T (line 12) | type T struct
function f (line 18) | func f(i int) int { return i * i }
function main (line 20) | func main() {
FILE: _test/struct40.go
type T (line 3) | type T struct
type T1 (line 8) | type T1 struct
function f (line 12) | func f(t *T) { println("in f") }
type xxx (line 16) | type xxx struct
function main (line 18) | func main() {
FILE: _test/struct41.go
type Ti (line 3) | type Ti
type T1 (line 5) | type T1 struct
type T (line 9) | type T struct
function f (line 14) | func f(t *T) { println("in f") }
type xxx (line 16) | type xxx struct
function main (line 20) | func main() {
FILE: _test/struct42.go
type T (line 3) | type T struct
function f (line 8) | func f(t *T) { println("in f") }
type xxx (line 12) | type xxx struct
function main (line 14) | func main() {
FILE: _test/struct43.go
type T (line 3) | type T struct
function f (line 8) | func f(t *T) { println("in f") }
type xxx (line 10) | type xxx struct
function main (line 12) | func main() {
FILE: _test/struct44.go
type Ti (line 3) | type Ti
type T1 (line 5) | type T1 struct
type T (line 9) | type T struct
function f (line 14) | func f(t *T) X { println("in f"); return X{} }
type X (line 16) | type X struct
type xxx (line 18) | type xxx struct
function main (line 22) | func main() {
FILE: _test/struct45.go
type T (line 3) | type T struct
type T1 (line 7) | type T1 struct
function main (line 11) | func main() {
FILE: _test/struct46.go
type A (line 5) | type A struct
type D (line 10) | type D struct
function main (line 15) | func main() {
FILE: _test/struct47.go
type A (line 5) | type A struct
method Test (line 10) | func (a *A) Test() string {
type D (line 14) | type D struct
function main (line 18) | func main() {
FILE: _test/struct48.go
type List (line 3) | type List struct
function add (line 8) | func add(l *List, n int) *List {
function pr (line 16) | func pr(l *List) {
function main (line 25) | func main() {
FILE: _test/struct49.go
type S (line 3) | type S struct
method getT (line 11) | func (c *S) getT(addr string) (t *T, ok bool) {
type T (line 7) | type T struct
function main (line 22) | func main() {
FILE: _test/struct5.go
type T (line 3) | type T struct
function f (line 8) | func f(i int) int { return i * i }
function main (line 10) | func main() {
FILE: _test/struct50.go
type Node (line 5) | type Node struct
function main (line 10) | func main() {
FILE: _test/struct51.go
type Node (line 8) | type Node struct
function main (line 13) | func main() {
FILE: _test/struct52.go
type Node (line 5) | type Node struct
function main (line 10) | func main() {
FILE: _test/struct53.go
type T1 (line 5) | type T1 struct
type T2 (line 9) | type T2 struct
type T (line 13) | type T struct
function main (line 18) | func main() {
FILE: _test/struct54.go
type S (line 3) | type S struct
function newS (line 7) | func newS() *S {
type T (line 13) | type T struct
type U (line 17) | type U struct
function main (line 21) | func main() {
FILE: _test/struct55.go
type Logger (line 8) | type Logger struct
method Infof (line 12) | func (l *Logger) Infof(format string, args ...interface{}) {
function main (line 16) | func main() {
FILE: _test/struct56.go
type A (line 8) | type A struct
type InnerA (line 12) | type InnerA struct
function main (line 16) | func main() {
FILE: _test/struct57.go
type A (line 8) | type A struct
type InnerA (line 12) | type InnerA struct
function main (line 16) | func main() {
FILE: _test/struct58.go
type A (line 8) | type A struct
function main (line 12) | func main() {
FILE: _test/struct59.go
type A (line 7) | type A struct
type C (line 12) | type C struct
type D (line 17) | type D struct
type E (line 22) | type E struct
type B (line 27) | type B struct
type F (line 28) | type F struct
type G (line 29) | type G struct
type H (line 30) | type H struct
function main (line 32) | func main() {
FILE: _test/struct6.go
type T (line 3) | type T struct
function main (line 7) | func main() {
FILE: _test/struct60.go
type data (line 7) | type data struct
function render (line 11) | func render(v interface{}) {
function main (line 15) | func main() {
FILE: _test/struct61.go
type A (line 5) | type A struct
type D (line 10) | type D struct
function main (line 15) | func main() {
FILE: _test/struct62.go
function main (line 3) | func main() {
FILE: _test/struct7.go
type Opt (line 3) | type Opt struct
type T (line 7) | type T struct
function main (line 12) | func main() {
FILE: _test/struct8.go
type T3 (line 3) | type T3 struct
type T2 (line 7) | type T2 struct
type T (line 12) | type T struct
function f (line 18) | func f(i int) int { return i * i }
function main (line 20) | func main() {
FILE: _test/struct9.go
type T (line 3) | type T struct
function main (line 8) | func main() {
FILE: _test/switch.go
function main (line 3) | func main() {
FILE: _test/switch0.go
function f (line 5) | func f(i int) bool {
function main (line 16) | func main() {
FILE: _test/switch1.go
function main (line 3) | func main() {
FILE: _test/switch10.go
function main (line 3) | func main() {
FILE: _test/switch11.go
function main (line 3) | func main() {
FILE: _test/switch12.go
function main (line 3) | func main() {
FILE: _test/switch13.go
function main (line 3) | func main() {
FILE: _test/switch14.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 21) | func (b Boo) Hello() {
type Bir (line 13) | type Bir struct
type Bar (line 17) | type Bar struct
method Hello (line 19) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 26) | func inCall(foo fii) {
function main (line 36) | func main() {
FILE: _test/switch15.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 21) | func (b Boo) Hello() {
type Bir (line 13) | type Bir struct
type Bar (line 17) | type Bar struct
method Hello (line 19) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 26) | func inCall(foo fii) {
function main (line 36) | func main() {
FILE: _test/switch16.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 21) | func (b Boo) Hello() {
type Bir (line 13) | type Bir struct
type Bar (line 17) | type Bar struct
method Hello (line 19) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 26) | func inCall(foo fii) {
function main (line 36) | func main() {
FILE: _test/switch17.go
type fii (line 5) | type fii interface
type Boo (line 9) | type Boo struct
method Hello (line 21) | func (b Boo) Hello() {
type Bir (line 13) | type Bir struct
type Bar (line 17) | type Bar struct
method Hello (line 19) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 26) | func inCall(foo fii) {
function main (line 40) | func main() {
FILE: _test/switch18.go
type fii (line 5) | type fii interface
type Bir (line 9) | type Bir struct
method Yo (line 11) | func (b Bir) Yo() {
method Hello (line 15) | func (b Bir) Hello() {
type Boo (line 19) | type Boo struct
method Hello (line 23) | func (b Boo) Hello() {
type Bar (line 28) | type Bar struct
method Hello (line 30) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 32) | func inCall(foo fii) {
function main (line 44) | func main() {
FILE: _test/switch19.go
type fii (line 5) | type fii interface
type Bir (line 9) | type Bir struct
method Yo (line 11) | func (b Bir) Yo() {
method Hello (line 15) | func (b Bir) Hello() {
type Boo (line 19) | type Boo struct
method Hello (line 23) | func (b Boo) Hello() {
type Bar (line 28) | type Bar struct
method Hello (line 30) | func (b Bar) Hello() { fmt.Println("b:", b) }
function inCall (line 32) | func inCall(foo fii) {
function main (line 44) | func main() {
FILE: _test/switch2.go
function main (line 3) | func main() {
FILE: _test/switch20.go
function main (line 3) | func main() {
FILE: _test/switch21.go
function main (line 5) | func main() {
FILE: _test/switch22.go
type T (line 3) | type T struct
function f (line 7) | func f(t interface{}) {
function main (line 16) | func main() {
FILE: _test/switch23.go
function getType (line 3) | func getType() string { return "T1" }
function main (line 5) | func main() {
FILE: _test/switch24.go
function main (line 3) | func main() {
FILE: _test/switch25.go
function main (line 3) | func main() {
FILE: _test/switch26.go
function main (line 3) | func main() {
FILE: _test/switch27.go
function main (line 3) | func main() {
FILE: _test/switch28.go
function main (line 3) | func main() {
FILE: _test/switch29.go
function main (line 3) | func main() {
FILE: _test/switch3.go
function main (line 3) | func main() {
FILE: _test/switch30.go
function main (line 3) | func main() {
FILE: _test/switch31.go
function main (line 3) | func main() {
FILE: _test/switch32.go
function main (line 3) | func main() {
FILE: _test/switch33.go
function main (line 3) | func main() {
FILE: _test/switch34.go
function main (line 3) | func main() {
FILE: _test/switch35.go
function main (line 3) | func main() {
FILE: _test/switch36.go
function main (line 3) | func main() {
FILE: _test/switch37.go
function main (line 3) | func main() {
FILE: _test/switch38.go
function isSeparator (line 3) | func isSeparator(c byte) bool {
function main (line 11) | func main() {
FILE: _test/switch39.go
function f (line 3) | func f(params ...interface{}) {
function main (line 12) | func main() {
FILE: _test/switch4.go
function main (line 3) | func main() {
FILE: _test/switch40.go
function f (line 3) | func f(params ...interface{}) {
function main (line 12) | func main() {
FILE: _test/switch5.go
function main (line 3) | func main() {
FILE: _test/switch6.go
function main (line 3) | func main() {
FILE: _test/switch7.go
function main (line 3) | func main() {
FILE: _test/switch8.go
function main (line 3) | func main() {
FILE: _test/switch9.go
function main (line 3) | func main() {
FILE: _test/tag0.go
function main (line 8) | func main() {
FILE: _test/testdata/redeclaration-global7/src/guthib.com/bar/quux.go
function Quux (line 3) | func Quux() string {
FILE: _test/testdata/redeclaration-global7/src/guthib.com/baz/quux.go
function Quux (line 3) | func Quux() string {
FILE: _test/testdata/redeclaration-global7/src/guthib.com/tata/tutu.go
function Quux (line 5) | func Quux() string {
FILE: _test/testdata/redeclaration-global7/src/guthib.com/toto/titi.go
function Quux (line 5) | func Quux() string {
FILE: _test/time0.go
function main (line 8) | func main() {
FILE: _test/time1.go
function main (line 8) | func main() {
FILE: _test/time10.go
function main (line 7) | func main() {
FILE: _test/time11.go
constant df (line 8) | df = time.Minute * 30
function main (line 10) | func main() {
FILE: _test/time12.go
function main (line 10) | func main() {
FILE: _test/time13.go
function main (line 12) | func main() {
FILE: _test/time14.go
function f (line 10) | func f() time.Time {
function main (line 15) | func main() {
FILE: _test/time15.go
type TimeValue (line 5) | type TimeValue
method decode (line 7) | func (v *TimeValue) decode() { println("in decode") }
function main (line 9) | func main() {
FILE: _test/time16.go
function main (line 5) | func main() {
FILE: _test/time2.go
function main (line 8) | func main() {
FILE: _test/time3.go
function main (line 9) | func main() {
FILE: _test/time4.go
function main (line 8) | func main() {
FILE: _test/time5.go
function main (line 8) | func main() {
FILE: _test/time6.go
function main (line 8) | func main() {
FILE: _test/time7.go
function main (line 10) | func main() { fmt.Println(d) }
FILE: _test/time8.go
type durationValue (line 7) | type durationValue
method String (line 9) | func (d *durationValue) String() string { return (*time.Duration)(d).S...
function main (line 11) | func main() {
FILE: _test/time9.go
function main (line 8) | func main() {
FILE: _test/type0.go
type newInt (line 3) | type newInt
function main (line 5) | func main() {
FILE: _test/type1.go
function main (line 5) | func main() {
FILE: _test/type10.go
function main (line 11) | func main() {
FILE: _test/type11.go
function main (line 11) | func main() {
FILE: _test/type12.go
type T1 (line 3) | type T1 struct
method Get (line 7) | func (t *T1) Get() string {
type T2 (line 11) | type T2 struct
method V (line 15) | func (t *T2) V() *T2 {
function main (line 24) | func main() {
FILE: _test/type13.go
type T (line 5) | type T struct
function main (line 7) | func main() {
FILE: _test/type14.go
type T (line 7) | type T struct
function main (line 9) | func main() {
FILE: _test/type15.go
function main (line 3) | func main() {
FILE: _test/type16.go
function main (line 5) | func main() {
FILE: _test/type17.go
function main (line 5) | func main() {
FILE: _test/type18.go
type T (line 3) | type T struct
function main (line 15) | func main() {
FILE: _test/type19.go
type T (line 3) | type T struct
function main (line 16) | func main() {
FILE: _test/type2.go
type Options (line 8) | type Options struct
type T1 (line 12) | type T1 struct
function main (line 17) | func main() {
FILE: _test/type20.go
function isCloser (line 8) | func isCloser(r io.Reader) bool {
function main (line 13) | func main() {
FILE: _test/type21.go
function main (line 8) | func main() {
FILE: _test/type22.go
type T1 (line 3) | type T1
function foo (line 5) | func foo() T1 {
type T (line 9) | type T struct
function main (line 13) | func main() {
FILE: _test/type23.go
function main (line 8) | func main() {
FILE: _test/type24.go
function main (line 9) | func main() {
function assertInt (line 15) | func assertInt() {
function assertNil (line 25) | func assertNil() {
function assertValue (line 35) | func assertValue() {
FILE: _test/type25.go
type wrappedError (line 8) | type wrappedError struct
method Error (line 12) | func (e wrappedError) Error() string {
method Unwrap (line 16) | func (e wrappedError) Unwrap() error {
function getWrapped (line 22) | func getWrapped() *wrappedError {
function main (line 32) | func main() {
FILE: _test/type26.go
type wrappedError (line 8) | type wrappedError struct
method Error (line 12) | func (e *wrappedError) Error() string {
method Unwrap (line 16) | func (e *wrappedError) Unwrap() error {
function getWrapped (line 22) | func getWrapped() *wrappedError {
function main (line 32) | func main() {
FILE: _test/type27.go
method Bar (line 7) | func (f Foo) Bar() int {
function main (line 11) | func main() {
FILE: _test/type28.go
method Bar (line 7) | func (f *Foo) Bar() int {
function main (line 11) | func main() {
FILE: _test/type29.go
method Bar (line 5) | func (f Foo) Bar() int {
function main (line 9) | func main() {}
FILE: _test/type3.go
type S1 (line 5) | type S1
function main (line 7) | func main() {
FILE: _test/type30.go
method Bar (line 5) | func (f Foo) Bar() int {
function main (line 9) | func main() {}
FILE: _test/type31.go
method Bar (line 5) | func (f Foo) Bar() int {
function main (line 11) | func main() {
FILE: _test/type32.go
method Bar (line 5) | func (f *Foo) Bar() int {
function main (line 11) | func main() {
FILE: _test/type33.go
method Bar (line 3) | func (f *Foo) Bar() int {
function main (line 7) | func main() {
FILE: _test/type34.go
type original (line 3) | type original struct
function main (line 7) | func main() {
FILE: _test/type4.go
function main (line 8) | func main() {
FILE: _test/type5.go
type T (line 8) | type T
function main (line 10) | func main() {
FILE: _test/type6.go
function main (line 8) | func main() {
type T (line 13) | type T
FILE: _test/type7.go
function main (line 5) | func main() {
FILE: _test/type8.go
function main (line 8) | func main() {
FILE: _test/type9.go
type Hello (line 5) | type Hello struct
function main (line 9) | func main() {
type GoodbyeProvider (line 15) | type GoodbyeProvider
FILE: _test/unsafe0.go
function main (line 5) | func main() {
FILE: _test/unsafe1.go
type S (line 5) | type S struct
function main (line 9) | func main() {
FILE: _test/unsafe10.go
type T (line 5) | type T struct
function f (line 10) | func f(off uintptr) { println(off) }
function main (line 12) | func main() {
FILE: _test/unsafe2.go
function main (line 8) | func main() {
FILE: _test/unsafe3.go
constant SSize (line 9) | SSize = 16
constant WSize (line 10) | WSize = bits.UintSize / 8
type S (line 13) | type S struct
function main (line 18) | func main() {
FILE: _test/unsafe4.go
constant WSize (line 9) | WSize = bits.UintSize / 8
type S (line 11) | type S struct
function main (line 17) | func main() {
FILE: _test/unsafe5.go
constant WSize (line 8) | WSize = bits.UintSize / 8
type S (line 10) | type S struct
function main (line 16) | func main() {
FILE: _test/unsafe6.go
type S (line 8) | type S struct
function main (line 14) | func main() {
FILE: _test/unsafe7.go
type S (line 8) | type S struct
function main (line 14) | func main() {
FILE: _test/unsafe8.go
type T (line 5) | type T struct
function main (line 13) | func main() {
FILE: _test/var.go
function main (line 3) | func main() {
FILE: _test/var10.go
function main (line 6) | func main() {
FILE: _test/var11.go
function main (line 5) | func main() {
FILE: _test/var12.go
function main (line 8) | func main() {
FILE: _test/var13.go
function concat (line 10) | func concat(a ...string) string {
function main (line 18) | func main() {
FILE: _test/var14.go
function main (line 5) | func main() {
FILE: _test/var15.go
function inca (line 5) | func inca() {
function main (line 9) | func main() {
FILE: _test/var16.go
function getArray (line 3) | func getArray() ([]int, error) { println("getArray"); return []int{1, 2}...
function getNum (line 5) | func getNum() (int, error) { println("getNum"); return 3, nil }
function main (line 7) | func main() {
FILE: _test/var2.go
function main (line 3) | func main() {
FILE: _test/var3.go
function main (line 3) | func main() {
FILE: _test/var4.go
function main (line 3) | func main() {
FILE: _test/var5.go
function main (line 5) | func main() {
FILE: _test/var6.go
type Foo (line 7) | type Foo struct
function Hello (line 13) | func Hello() {
function main (line 19) | func main() {
FILE: _test/var7.go
type T (line 7) | type T struct
function main (line 13) | func main() {
FILE: _test/var8.go
type Message (line 8) | type Message struct
function main (line 14) | func main() {
FILE: _test/var9.go
function main (line 6) | func main() {
FILE: _test/variadic.go
function f (line 5) | func f(a ...int) {
function main (line 9) | func main() {
FILE: _test/variadic0.go
function f (line 5) | func f(s string, a ...int) {
function main (line 9) | func main() {
FILE: _test/variadic1.go
function f (line 5) | func f(s string, a ...int32) {
function main (line 9) | func main() {
FILE: _test/variadic10.go
function main (line 8) | func main() {
FILE: _test/variadic2.go
function f (line 5) | func f(a ...int) {
function main (line 11) | func main() {
FILE: _test/variadic3.go
function f (line 5) | func f(a ...int) int {
function main (line 14) | func main() {
FILE: _test/variadic4.go
function variadic (line 3) | func variadic(s ...string) {}
function f (line 5) | func f(s string) { println(s + "bar") }
function main (line 7) | func main() { f("foo") }
FILE: _test/variadic5.go
type A (line 7) | type A struct
method f (line 10) | func (a A) f(vals ...bool) {
function main (line 16) | func main() {
FILE: _test/variadic6.go
type A (line 5) | type A struct
method f (line 8) | func (a A) f(vals ...bool) {
function main (line 13) | func main() {
FILE: _test/variadic7.go
function main (line 5) | func main() {
FILE: _test/variadic8.go
function main (line 8) | func main() {
FILE: _test/variadic9.go
function Sprintf (line 5) | func Sprintf(format string, a ...interface{}) string {
function main (line 9) | func main() {
FILE: _test/vars/first.go
function concat (line 8) | func concat(a ...string) string {
FILE: cmd/yaegi/extract.go
function extractCmd (line 17) | func extractCmd(arg []string) error {
function genLicense (line 104) | func genLicense(fname string) (string, error) {
FILE: cmd/yaegi/help.go
constant usage (line 5) | usage = `Yaegi is a Go interpreter.
function help (line 25) | func help(arg []string) error {
FILE: cmd/yaegi/run.go
function run (line 19) | func run(arg []string) error {
function isFile (line 131) | func isFile(path string) bool {
function runFile (line 136) | func runFile(i *interp.Interpreter, path string, noAutoImport bool) error {
function showError (line 157) | func showError(err error) {
FILE: cmd/yaegi/test.go
function test (line 22) | func test(arg []string) (err error) {
FILE: cmd/yaegi/yaegi.go
constant Extract (line 107) | Extract = "extract"
constant Help (line 108) | Help = "help"
constant Run (line 109) | Run = "run"
constant Test (line 110) | Test = "test"
constant Version (line 111) | Version = "version"
function main (line 116) | func main() {
FILE: cmd/yaegi/yaegi_test.go
constant CITimeoutMultiplier (line 18) | CITimeoutMultiplier = 3
function Sleep (line 22) | func Sleep(d time.Duration) {
function applyCIMultiplier (line 27) | func applyCIMultiplier(timeout time.Duration) time.Duration {
function TestYaegiCmdCancel (line 39) | func TestYaegiCmdCancel(t *testing.T) {
function raceDetectorSupported (line 120) | func raceDetectorSupported(goos, goarch string) bool {
FILE: example/closure/_pkg/src/foo/bar/bar.go
function NewSample (line 9) | func NewSample() func(string, string) func(string) string {
FILE: example/closure/closure_test.go
function TestFunctionCall (line 10) | func TestFunctionCall(t *testing.T) {
FILE: example/fs/fs_test.go
function TestFilesystemMapFS (line 52) | func TestFilesystemMapFS(t *testing.T) {
FILE: example/getfunc/_gopath/src/github.com/foo/bar/foobar.go
type Foo (line 3) | type Foo struct
function NewFoo (line 7) | func NewFoo() *Foo {
FILE: example/getfunc/getfunc_test.go
function TestGetFunc (line 11) | func TestGetFunc(t *testing.T) {
FILE: example/pkg/_pkg/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg0/src/github.com/foo/pkg/fromage/cheese/cheese.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg0/src/github.com/foo/pkg/fromage/fromage.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg0/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg1/src/github.com/foo/pkg/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg1/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg10/src/github.com/foo/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg10/src/github.com/foo/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg11/src/foo/foo.go
function main (line 9) | func main() {
FILE: example/pkg/_pkg11/src/foo/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg12/src/guthib.com/foo/main.go
function main (line 9) | func main() {
FILE: example/pkg/_pkg12/src/guthib.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg12/src/guthib.com/foo/vendor/guthib.com/bar/bar.go
function Bar (line 4) | func Bar() string {
FILE: example/pkg/_pkg13/src/guthib.com/foo/bar/main.go
function main (line 9) | func main() {
FILE: example/pkg/_pkg13/src/guthib.com/foo/bar/vendor/guthib.com/bat/baz/baz.go
function NewT (line 3) | func NewT() *T {
type T (line 10) | type T struct
type U (line 15) | type U struct
type V (line 20) | type V struct
FILE: example/pkg/_pkg2/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg2/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg2/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/vendor/guthib.com/traefik/cheese/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg3/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg3/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/couteau/couteau.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg3/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 10) | func Hello() string {
FILE: example/pkg/_pkg3/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/vendor/guthib.com/traefik/cheese/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg4/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg4/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/couteau/couteau.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg4/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 10) | func Hello() string {
FILE: example/pkg/_pkg4/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/vendor/guthib.com/traefik/cheese/cheese.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg4/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/vendor/guthib.com/traefik/cheese/vin/vin.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg5/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg5/src/github.com/foo/pkg/vendor/guthib.com/traefik/cheese/cheese.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg5/src/github.com/foo/pkg/vendor/guthib.com/traefik/cheese/vin/vin.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg5/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/couteau/couteau.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg5/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 10) | func Hello() string {
FILE: example/pkg/_pkg6/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg6/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/couteau/couteau.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg6/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 10) | func Hello() string {
FILE: example/pkg/_pkg6/src/guthib.com/traefik/cheese/cheese.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg6/src/guthib.com/traefik/cheese/vin/vin.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg7/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg7/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg7/src/github.com/foo/pkg/vendor/guthib.com/traefik/vin/vendor/guthib.com/traefik/cheese/cheese.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg7/src/github.com/foo/pkg/vendor/guthib.com/traefik/vin/vin.go
function Hello (line 9) | func Hello() string {
FILE: example/pkg/_pkg8/src/github.com/foo/pkg/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg8/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg9/src/github.com/foo/pkg/fromage/fromage.go
function Hello (line 5) | func Hello() string {
FILE: example/pkg/_pkg9/src/github.com/foo/pkg/pkg.go
function Here (line 9) | func Here() string {
function NewSample (line 13) | func NewSample() func() string {
FILE: example/pkg/_pkg9/src/github.com/foo/pkg/pkgfalse.go
function HereNot (line 9) | func HereNot() string {
function NewSampleNot (line 13) | func NewSampleNot() func() string {
FILE: example/pkg/pkg_test.go
function TestPackages (line 14) | func TestPackages(t *testing.T) {
function fatalStderrf (line 151) | func fatalStderrf(t *testing.T, format string, args ...interface{}) {
function TestPackagesError (line 158) | func TestPackagesError(t *testing.T) {
FILE: extract/extract.go
constant model (line 28) | model = `// Code generated by 'yaegi extract {{.ImportPath}}'. DO NOT EDIT.
type Val (line 98) | type Val struct
type Method (line 104) | type Method struct
type Wrap (line 109) | type Wrap struct
function matchList (line 125) | func matchList(name string, list []string) (match bool, err error) {
type Extractor (line 136) | type Extractor struct
method genContent (line 144) | func (e *Extractor) genContent(importPath string, p *types.Package) ([...
method importPath (line 378) | func (e *Extractor) importPath(pkgIdent, importPath string) (string, e...
method Extract (line 444) | func (e *Extractor) Extract(pkgIdent, importPath string, rw io.Writer)...
function fixConst (line 339) | func fixConst(name string, val constant.Value, imports map[string]bool) ...
function GetMinor (line 468) | func GetMinor(part string) string {
constant defaultMinorVersion (line 481) | defaultMinorVersion = 22
function genBuildTags (line 483) | func genBuildTags() (string, error) {
function isInStdlib (line 509) | func isInStdlib(path string) bool { return !strings.Contains(path, ".") }
FILE: extract/extract_test.go
function TestPackages (line 28) | func TestPackages(t *testing.T) {
FILE: extract/testdata/1/src/guthib.com/bar/main.go
function main (line 7) | func main() {
FILE: extract/testdata/1/src/guthib.com/baz/baz.go
function Hello (line 3) | func Hello() {
FILE: extract/testdata/2/src/guthib.com/bar/main.go
function main (line 7) | func main() {
FILE: extract/testdata/2/src/guthib.com/baz/baz.go
function Hello (line 3) | func Hello() {
FILE: extract/testdata/3/src/guthib.com/bar/main.go
function main (line 7) | func main() {
FILE: extract/testdata/3/src/guthib.com/baz/baz.go
function Hello (line 3) | func Hello() {
FILE: extract/testdata/4/src/guthib.com/bar/main.go
function main (line 7) | func main() {
FILE: extract/testdata/4/src/guthib.com/bar/vendor/guthib.com/baz/baz.go
function Hello (line 3) | func Hello() {
FILE: extract/testdata/5/src/guthib.com/bar/main.go
function main (line 7) | func main() {
FILE: extract/testdata/5/src/guthib.com/bar/vendor/guthib.com/baz/baz.go
function Hello (line 3) | func Hello() {
FILE: extract/testdata/6/src/guthib.com/bar/main.go
function main (line 7) | func main() {
FILE: extract/testdata/6/src/guthib.com/baz-baz/baz.go
function Hello (line 3) | func Hello() {
FILE: extract/testdata/7/src/guthib.com/variadic/variadic.go
type Variadic (line 3) | type Variadic interface
FILE: internal/cmd/extract/extract.go
function main (line 39) | func main() {
FILE: internal/cmd/genop/genop.go
constant model (line 12) | model = `package interp
type Op (line 1140) | type Op struct
function main (line 1150) | func main() {
FILE: internal/unsafe2/go1_20_unsafe.go
type dummy (line 12) | type dummy struct
type rtype (line 19) | type rtype struct
type emptyInterface (line 30) | type emptyInterface struct
type structField (line 35) | type structField struct
type structType (line 41) | type structType struct
function SetFieldType (line 50) | func SetFieldType(s reflect.Type, idx int, t reflect.Type) {
function unpackType (line 62) | func unpackType(t reflect.Type) *rtype {
FILE: internal/unsafe2/go1_21_unsafe.go
type dummy (line 12) | type dummy struct
type abiType (line 18) | type abiType struct
type abiName (line 32) | type abiName struct
type abiStructField (line 36) | type abiStructField struct
type abiStructType (line 42) | type abiStructType struct
type emptyInterface (line 48) | type emptyInterface struct
function SetFieldType (line 56) | func SetFieldType(s reflect.Type, idx int, t reflect.Type) {
function unpackType (line 68) | func unpackType(t reflect.Type) *abiType {
FILE: internal/unsafe2/unsafe_test.go
function TestSwapFieldType (line 10) | func TestSwapFieldType(t *testing.T) {
FILE: interp/ast.go
type nkind (line 17) | type nkind
method String (line 188) | func (k nkind) String() string {
constant undefNode (line 21) | undefNode nkind = iota
constant addressExpr (line 22) | addressExpr
constant arrayType (line 23) | arrayType
constant assignStmt (line 24) | assignStmt
constant assignXStmt (line 25) | assignXStmt
constant basicLit (line 26) | basicLit
constant binaryExpr (line 27) | binaryExpr
constant blockStmt (line 28) | blockStmt
constant branchStmt (line 29) | branchStmt
constant breakStmt (line 30) | breakStmt
constant callExpr (line 31) | callExpr
constant caseBody (line 32) | caseBody
constant caseClause (line 33) | caseClause
constant chanType (line 34) | chanType
constant chanTypeSend (line 35) | chanTypeSend
constant chanTypeRecv (line 36) | chanTypeRecv
constant commClause (line 37) | commClause
constant commClauseDefault (line 38) | commClauseDefault
constant compositeLitExpr (line 39) | compositeLitExpr
constant constDecl (line 40) | constDecl
constant continueStmt (line 41) | continueStmt
constant declStmt (line 42) | declStmt
constant deferStmt (line 43) | deferStmt
constant defineStmt (line 44) | defineStmt
constant defineXStmt (line 45) | defineXStmt
constant ellipsisExpr (line 46) | ellipsisExpr
constant exprStmt (line 47) | exprStmt
constant fallthroughtStmt (line 48) | fallthroughtStmt
constant fieldExpr (line 49) | fieldExpr
constant fieldList (line 50) | fieldList
constant fileStmt (line 51) | fileStmt
constant forStmt0 (line 52) | forStmt0
constant forStmt1 (line 53) | forStmt1
constant forStmt2 (line 54) | forStmt2
constant forStmt3 (line 55) | forStmt3
constant forStmt4 (line 56) | forStmt4
constant forStmt5 (line 57) | forStmt5
constant forStmt6 (line 58) | forStmt6
constant forStmt7 (line 59) | forStmt7
constant forRangeStmt (line 60) | forRangeStmt
constant funcDecl (line 61) | funcDecl
constant funcLit (line 62) | funcLit
constant funcType (line 63) | funcType
constant goStmt (line 64) | goStmt
constant gotoStmt (line 65) | gotoStmt
constant identExpr (line 66) | identExpr
constant ifStmt0 (line 67) | ifStmt0
constant ifStmt1 (line 68) | ifStmt1
constant ifStmt2 (line 69) | ifStmt2
constant ifStmt3 (line 70) | ifStmt3
constant importDecl (line 71) | importDecl
constant importSpec (line 72) | importSpec
constant incDecStmt (line 73) | incDecStmt
constant indexExpr (line 74) | indexExpr
constant indexListExpr (line 75) | indexListExpr
constant interfaceType (line 76) | interfaceType
constant keyValueExpr (line 77) | keyValueExpr
constant labeledStmt (line 78) | labeledStmt
constant landExpr (line 79) | landExpr
constant lorExpr (line 80) | lorExpr
constant mapType (line 81) | mapType
constant parenExpr (line 82) | parenExpr
constant rangeStmt (line 83) | rangeStmt
constant returnStmt (line 84) | returnStmt
constant selectStmt (line 85) | selectStmt
constant selectorExpr (line 86) | selectorExpr
constant selectorImport (line 87) | selectorImport
constant sendStmt (line 88) | sendStmt
constant sliceExpr (line 89) | sliceExpr
constant starExpr (line 90) | starExpr
constant structType (line 91) | structType
constant switchStmt (line 92) | switchStmt
constant switchIfStmt (line 93) | switchIfStmt
constant typeAssertExpr (line 94) | typeAssertExpr
constant typeDecl (line 95) | typeDecl
constant typeSpec (line 96) | typeSpec
constant typeSpecAssign (line 97) | typeSpecAssign
constant typeSwitch (line 98) | typeSwitch
constant unaryExpr (line 99) | unaryExpr
constant valueSpec (line 100) | valueSpec
constant varDecl (line 101) | varDecl
type astError (line 196) | type astError
type action (line 199) | type action
method String (line 328) | func (a action) String() string {
constant aNop (line 205) | aNop action = iota
constant aAddr (line 206) | aAddr
constant aAssign (line 207) | aAssign
constant aAssignX (line 208) | aAssignX
constant aAdd (line 209) | aAdd
constant aAddAssign (line 210) | aAddAssign
constant aAnd (line 211) | aAnd
constant aAndAssign (line 212) | aAndAssign
constant aAndNot (line 213) | aAndNot
constant aAndNotAssign (line 214) | aAndNotAssign
constant aBitNot (line 215) | aBitNot
constant aBranch (line 216) | aBranch
constant aCall (line 217) | aCall
constant aCallSlice (line 218) | aCallSlice
constant aCase (line 219) | aCase
constant aCompositeLit (line 220) | aCompositeLit
constant aConvert (line 221) | aConvert
constant aDec (line 222) | aDec
constant aEqual (line 223) | aEqual
constant aGreater (line 224) | aGreater
constant aGreaterEqual (line 225) | aGreaterEqual
constant aGetFunc (line 226) | aGetFunc
constant aGetIndex (line 227) | aGetIndex
constant aGetMethod (line 228) | aGetMethod
constant aGetSym (line 229) | aGetSym
constant aInc (line 230) | aInc
constant aLand (line 231) | aLand
constant aLor (line 232) | aLor
constant aLower (line 233) | aLower
constant aLowerEqual (line 234) | aLowerEqual
constant aMethod (line 235) | aMethod
constant aMul (line 236) | aMul
constant aMulAssign (line 237) | aMulAssign
constant aNeg (line 238) | aNeg
constant aNot (line 239) | aNot
constant aNotEqual (line 240) | aNotEqual
constant aOr (line 241) | aOr
constant aOrAssign (line 242) | aOrAssign
constant aPos (line 243) | aPos
constant aQuo (line 244) | aQuo
constant aQuoAssign (line 245) | aQuoAssign
constant aRange (line 246) | aRange
constant aRecv (line 247) | aRecv
constant aRem (line 248) | aRem
constant aRemAssign (line 249) | aRemAssign
constant aReturn (line 250) | aReturn
constant aSend (line 251) | aSend
constant aShl (line 252) | aShl
constant aShlAssign (line 253) | aShlAssign
constant aShr (line 254) | aShr
constant aShrAssign (line 255) | aShrAssign
constant aSlice (line 256) | aSlice
constant aSlice0 (line 257) | aSlice0
constant aStar (line 258) | aStar
constant aSub (line 259) | aSub
constant aSubAssign (line 260) | aSubAssign
constant aTypeAssert (line 261) | aTypeAssert
constant aXor (line 262) | aXor
constant aXorAssign (line 263) | aXorAssign
function isAssignAction (line 335) | func isAssignAction(a action) bool {
method firstToken (line 344) | func (interp *Interpreter) firstToken(src string) token.Token {
function ignoreError (line 353) | func ignoreError(err error, src string) bool {
function wrapInMain (line 364) | func wrapInMain(src string) string {
method parse (line 368) | func (interp *Interpreter) parse(src, name string, inc bool) (node ast.N...
method ast (line 431) | func (interp *Interpreter) ast(f ast.Node) (string, *node, error) {
type astNode (line 942) | type astNode struct
type nodestack (line 947) | type nodestack
method push (line 949) | func (s *nodestack) push(n *node, a ast.Node) {
method pop (line 953) | func (s *nodestack) pop() astNode {
method top (line 960) | func (s *nodestack) top() astNode {
method dup (line 969) | func (interp *Interpreter) dup(nod, anc *node) *node {
FILE: interp/build.go
method buildOk (line 15) | func (interp *Interpreter) buildOk(ctx *build.Context, name, src string)...
function buildLineOk (line 35) | func buildLineOk(ctx *build.Context, line string) (ok bool) {
function buildOptionOk (line 50) | func buildOptionOk(ctx *build.Context, tag string) bool {
function buildTagOk (line 62) | func buildTagOk(ctx *build.Context, s string) (r bool) {
function setYaegiTags (line 89) | func setYaegiTags(ctx *build.Context, comments []*ast.CommentGroup) {
function contains (line 106) | func contains(tags []string, tag string) bool {
function goMinorVersion (line 116) | func goMinorVersion(ctx *build.Context) int {
function skipFile (line 132) | func skipFile(ctx *build.Context, p string, skipTest bool) bool {
FILE: interp/build_test.go
type testBuild (line 8) | type testBuild struct
function TestBuildTag (line 13) | func TestBuildTag(t *testing.T) {
function TestSkipFile (line 54) | func TestSkipFile(t *testing.T) {
function Test_goMinorVersion (line 92) | func Test_goMinorVersion(t *testing.T) {
FILE: interp/cfg.go
type cfgError (line 15) | type cfgError struct
method Error (line 20) | func (c *cfgError) Error() string { return c.error.Error() }
constant nilIdent (line 46) | nilIdent = "nil"
function init (line 48) | func init() {
method cfg (line 59) | func (interp *Interpreter) cfg(root *node, sc *scope, importPath, pkgNam...
function fixUntyped (line 2309) | func fixUntyped(nod *node, sc *scope) {
function compDefineX (line 2322) | func compDefineX(sc *scope, n *node) error {
function childPos (line 2436) | func childPos(n *node) int {
method cfgErrorf (line 2445) | func (n *node) cfgErrorf(format string, a ...interface{}) *cfgError {
function genRun (line 2455) | func genRun(nod *node) error {
function genGlobalVars (line 2481) | func genGlobalVars(roots []*node, sc *scope) (*node, error) {
function getVars (line 2499) | func getVars(n *node) (vars []*node) {
function genGlobalVarDecl (line 2508) | func genGlobalVarDecl(nodes []*node, sc *scope) (*node, error) {
function getVarDependencies (line 2550) | func getVarDependencies(nod *node, sc *scope) (deps []*node) {
function setFNext (line 2574) | func setFNext(cond, next *node) {
function getDefault (line 2588) | func getDefault(n *node) int {
function isBinType (line 2602) | func isBinType(v reflect.Value) bool { return v.IsValid() && v.Kind() ==...
method isType (line 2605) | func (n *node) isType(sc *scope) bool {
function wireChild (line 2645) | func wireChild(n *node, exclude ...nkind) {
function excludeNodeKind (line 2688) | func excludeNodeKind(child []*node, kinds []nkind) []*node {
method name (line 2707) | func (n *node) name() (s string) {
method isNatural (line 2718) | func (n *node) isNatural() bool {
method isNil (line 2762) | func (n *node) isNil() bool { return n.kind == basicLit && !n.rval.IsVal...
method fieldType (line 2765) | func (n *node) fieldType(m int) *node {
method lastChild (line 2788) | func (n *node) lastChild() *node { return n.child[len(n.child)-1] }
method hasAnc (line 2790) | func (n *node) hasAnc(nod *node) bool {
function isKey (line 2799) | func isKey(n *node) bool {
function isField (line 2807) | func isField(n *node) bool {
function isInInterfaceType (line 2811) | func isInInterfaceType(n *node) bool {
function isInConstOrTypeDecl (line 2822) | func isInConstOrTypeDecl(n *node) bool {
function isNewDefine (line 2837) | func isNewDefine(n *node, sc *scope) bool {
function isMethod (line 2856) | func isMethod(n *node) bool {
function isFuncField (line 2860) | func isFuncField(n *node) bool {
function isMapEntry (line 2864) | func isMapEntry(n *node) bool {
function isCall (line 2868) | func isCall(n *node) bool {
function isBinCall (line 2872) | func isBinCall(n *node, sc *scope) bool {
function mustReturnValue (line 2887) | func mustReturnValue(n *node) bool {
function isRegularCall (line 2899) | func isRegularCall(n *node) bool {
function variadicPos (line 2903) | func variadicPos(n *node) int {
function canExport (line 2914) | func canExport(name string) bool {
function getExec (line 2921) | func getExec(n *node) bltn {
function setExec (line 2933) | func setExec(n *node) {
function typeSwichAssign (line 2967) | func typeSwichAssign(n *node) bool {
function compositeGenerator (line 2972) | func compositeGenerator(n *node, typ *itype, rtyp reflect.Type) (gen blt...
function matchSelectorMethod (line 3024) | func matchSelectorMethod(sc *scope, n *node) (err error) {
function arrayTypeLen (line 3143) | func arrayTypeLen(n *node, sc *scope) (int, error) {
function isValueUntyped (line 3194) | func isValueUntyped(v reflect.Value) bool {
function isArithmeticAction (line 3203) | func isArithmeticAction(n *node) bool {
function isBoolAction (line 3211) | func isBoolAction(n *node) bool {
function isBlank (line 3219) | func isBlank(n *node) bool {
function alignof (line 3226) | func alignof(n *node) {
function offsetof (line 3232) | func offsetof(n *node) {
function sizeof (line 3241) | func sizeof(n *node) {
FILE: interp/compile_test.go
function TestCompileAST (line 12) | func TestCompileAST(t *testing.T) {
FILE: interp/debugger.go
type Debugger (line 28) | type Debugger struct
method Wait (line 223) | func (dbg *Debugger) Wait() (reflect.Value, error) {
method enterGoRoutine (line 229) | func (dbg *Debugger) enterGoRoutine() *debugRoutine {
method exitGoRoutine (line 245) | func (dbg *Debugger) exitGoRoutine(g *debugRoutine) {
method getGoRoutine (line 254) | func (dbg *Debugger) getGoRoutine(id int) (*debugRoutine, bool) {
method enterCall (line 262) | func (dbg *Debugger) enterCall(nFunc, nCall *node, f *frame) {
method exitCall (line 290) | func (dbg *Debugger) exitCall(nFunc, nCall *node, f *frame) {
method exec (line 302) | func (dbg *Debugger) exec(n *node, f *frame) (stop bool) {
method Continue (line 348) | func (dbg *Debugger) Continue(id int) error {
method Step (line 380) | func (dbg *Debugger) Step(id int, reason DebugEventReason) error {
method Interrupt (line 399) | func (dbg *Debugger) Interrupt(id int, reason DebugEventReason) bool {
method Terminate (line 410) | func (dbg *Debugger) Terminate() {
method SetBreakpoints (line 484) | func (dbg *Debugger) SetBreakpoints(target BreakpointTarget, requests ...
method GoRoutines (line 537) | func (dbg *Debugger) GoRoutines() []*DebugGoRoutine {
type debugRoutine (line 44) | type debugRoutine struct
method setMode (line 360) | func (g *debugRoutine) setMode(reason DebugEventReason) {
type nodeDebugData (line 56) | type nodeDebugData struct
type frameDebugData (line 63) | type frameDebugData struct
type frameKind (line 72) | type frameKind
constant frameRoot (line 76) | frameRoot frameKind = iota + 1
constant frameCall (line 79) | frameCall
constant frameClosure (line 82) | frameClosure
type DebugOptions (line 86) | type DebugOptions struct
type DebugEvent (line 92) | type DebugEvent struct
method GoRoutine (line 555) | func (evt *DebugEvent) GoRoutine() int {
method Reason (line 563) | func (evt *DebugEvent) Reason() DebugEventReason {
method walkFrames (line 569) | func (evt *DebugEvent) walkFrames(fn func([]*frame) bool) {
method FrameDepth (line 603) | func (evt *DebugEvent) FrameDepth() int {
method Frames (line 614) | func (evt *DebugEvent) Frames(start, end int) []*DebugFrame {
type DebugFrame (line 100) | type DebugFrame struct
method Name (line 632) | func (f *DebugFrame) Name() string {
method Position (line 654) | func (f *DebugFrame) Position() token.Position {
method Program (line 664) | func (f *DebugFrame) Program() *Program {
method Scopes (line 674) | func (f *DebugFrame) Scopes() []*DebugFrameScope {
type DebugFrameScope (line 107) | type DebugFrameScope struct
method IsClosure (line 683) | func (f *DebugFrameScope) IsClosure() bool {
method Variables (line 688) | func (f *DebugFrameScope) Variables() []*DebugVariable {
type DebugVariable (line 112) | type DebugVariable struct
type DebugGoRoutine (line 119) | type DebugGoRoutine struct
method ID (line 549) | func (r *DebugGoRoutine) ID() int { return r.id }
method Name (line 552) | func (r *DebugGoRoutine) Name() string { return fmt.Sprintf("Goroutine...
type Breakpoint (line 124) | type Breakpoint struct
type DebugEventReason (line 133) | type DebugEventReason
constant debugRun (line 137) | debugRun DebugEventReason = iota
constant DebugPause (line 141) | DebugPause
constant DebugBreak (line 144) | DebugBreak
constant DebugEntry (line 148) | DebugEntry
constant DebugStepInto (line 152) | DebugStepInto
constant DebugStepOver (line 156) | DebugStepOver
constant DebugStepOut (line 160) | DebugStepOut
constant DebugTerminate (line 164) | DebugTerminate
constant DebugEnterGoRoutine (line 167) | DebugEnterGoRoutine
constant DebugExitGoRoutine (line 170) | DebugExitGoRoutine
method Debug (line 178) | func (interp *Interpreter) Debug(ctx context.Context, prog *Program, eve...
type BreakpointTarget (line 423) | type BreakpointTarget
function PathBreakpointTarget (line 428) | func PathBreakpointTarget(path string) BreakpointTarget {
function ProgramBreakpointTarget (line 441) | func ProgramBreakpointTarget(prog *Program) BreakpointTarget {
function AllBreakpointTarget (line 449) | func AllBreakpointTarget() BreakpointTarget {
type breakpointSetup (line 457) | type breakpointSetup struct
type BreakpointRequest (line 464) | type BreakpointRequest
function LineBreakpoint (line 467) | func LineBreakpoint(line int) BreakpointRequest {
function FunctionBreakpoint (line 474) | func FunctionBreakpoint(name string) BreakpointRequest {
function scanScope (line 712) | func scanScope(sc *scope, index map[int]string) {
FILE: interp/dot.go
method astDot (line 13) | func (n *node) astDot(out io.Writer, name string) {
method cfgDot (line 39) | func (n *node) cfgDot(out io.Writer) {
type nopCloser (line 62) | type nopCloser struct
method Close (line 66) | func (nopCloser) Close() error { return nil }
function dotWriter (line 69) | func dotWriter(dotCmd string) io.WriteCloser {
function defaultDotCmd (line 85) | func defaultDotCmd(filePath, prefix string) string {
FILE: interp/example_eval_test.go
function Example_eval (line 11) | func Example_eval() {
FILE: interp/export_test.go
method Scopes (line 3) | func (interp *Interpreter) Scopes() map[string]map[string]struct{} {
method Packages (line 15) | func (interp *Interpreter) Packages() map[string]string {
FILE: interp/generic.go
function genAST (line 12) | func genAST(sc *scope, root *node, types []*itype) (*node, bool, error) {
function copyNode (line 182) | func copyNode(n, anc *node, recursive bool) *node {
function inferTypesFromCall (line 211) | func inferTypesFromCall(sc *scope, fun *node, args []*node) ([]*itype, e...
function checkConstraint (line 304) | func checkConstraint(it, ct *itype) error {
FILE: interp/gta.go
method gta (line 12) | func (interp *Interpreter) gta(root *node, rpath, importPath, pkgName st...
function baseType (line 378) | func baseType(t *itype) *itype {
method gtaRetry (line 390) | func (interp *Interpreter) gtaRetry(nodes []*node, importPath, pkgName s...
function definedType (line 426) | func definedType(typ *itype) error {
function equalNodes (line 464) | func equalNodes(a, b []*node) bool {
FILE: interp/hooks.go
type convertFn (line 6) | type convertFn
type hooks (line 9) | type hooks struct
method Parse (line 13) | func (h *hooks) Parse(m map[string]reflect.Value) {
function getConvertFn (line 19) | func getConvertFn(v reflect.Value) (convertFn, bool) {
FILE: interp/interp.go
type node (line 27) | type node struct
method shouldBreak (line 58) | func (n *node) shouldBreak() bool {
method setProgram (line 70) | func (n *node) setProgram(p *Program) {
method setBreakOnCall (line 77) | func (n *node) setBreakOnCall(v bool) {
method setBreakOnLine (line 87) | func (n *node) setBreakOnLine(v bool) {
method Walk (line 281) | func (n *node) Walk(in func(n *node) bool, out func(n *node)) {
type receiver (line 98) | type receiver struct
type frame (line 105) | type frame struct
method runid (line 138) | func (f *frame) runid() uint64 { return atomic.LoadUint64(&f.id) }
method setrunid (line 139) | func (f *frame) setrunid(id uint64) { atomic.StoreUint64(&f.id, id) }
method clone (line 140) | func (f *frame) clone() *frame {
function newFrame (line 123) | func newFrame(anc *frame, length int, id uint64) *frame {
type Exports (line 160) | type Exports
type imports (line 163) | type imports
type opt (line 166) | type opt struct
type Interpreter (line 186) | type Interpreter struct
method resizeFrame (line 479) | func (interp *Interpreter) resizeFrame() {
method Eval (line 495) | func (interp *Interpreter) Eval(src string) (res reflect.Value, err er...
method EvalPath (line 502) | func (interp *Interpreter) EvalPath(path string) (res reflect.Value, e...
method EvalPathWithContext (line 519) | func (interp *Interpreter) EvalPathWithContext(ctx context.Context, pa...
method EvalTest (line 544) | func (interp *Interpreter) EvalTest(path string) error {
method eval (line 554) | func (interp *Interpreter) eval(src, name string, inc bool) (res refle...
method EvalWithContext (line 569) | func (interp *Interpreter) EvalWithContext(ctx context.Context, src st...
method stop (line 603) | func (interp *Interpreter) stop() {
method runid (line 608) | func (interp *Interpreter) runid() uint64 { return atomic.LoadUint64(&...
method ImportUsed (line 632) | func (interp *Interpreter) ImportUsed() {
method REPL (line 666) | func (interp *Interpreter) REPL() (reflect.Value, error) {
constant mainID (line 223) | mainID = "main"
constant selfPrefix (line 224) | selfPrefix = "github.com/traefik/yaegi"
constant selfPath (line 225) | selfPath = selfPrefix + "/interp/interp"
constant DefaultSourceName (line 229) | DefaultSourceName = "_.go"
constant Test (line 232) | Test = false
constant NoTest (line 234) | NoTest = true
function init (line 251) | func init() { Symbols[selfPath]["Symbols"] = reflect.ValueOf(Symbols) }
type _error (line 254) | type _error struct
method Error (line 259) | func (w _error) Error() string { return w.WError() }
type Panic (line 262) | type Panic struct
method Error (line 277) | func (e Panic) Error() string { return fmt.Sprint(e.Value) }
type Options (line 294) | type Options struct
function New (line 323) | func New(options Options) *Interpreter {
constant bltnAlignof (line 403) | bltnAlignof = "unsafe.Alignof"
constant bltnAppend (line 404) | bltnAppend = "append"
constant bltnCap (line 405) | bltnCap = "cap"
constant bltnClose (line 406) | bltnClose = "close"
constant bltnComplex (line 407) | bltnComplex = "complex"
constant bltnImag (line 408) | bltnImag = "imag"
constant bltnCopy (line 409) | bltnCopy = "copy"
constant bltnDelete (line 410) | bltnDelete = "delete"
constant bltnLen (line 411) | bltnLen = "len"
constant bltnMake (line 412) | bltnMake = "make"
constant bltnNew (line 413) | bltnNew = "new"
constant bltnOffsetof (line 414) | bltnOffsetof = "unsafe.Offsetof"
constant bltnPanic (line 415) | bltnPanic = "panic"
constant bltnPrint (line 416) | bltnPrint = "print"
constant bltnPrintln (line 417) | bltnPrintln = "println"
constant bltnReal (line 418) | bltnReal = "real"
constant bltnRecover (line 419) | bltnRecover = "recover"
constant bltnSizeof (line 420) | bltnSizeof = "unsafe.Sizeof"
function initUniverse (line 423) | func initUniverse() *scope {
function isFile (line 549) | func isFile(filesystem fs.FS, path string) bool {
function ignoreScannerError (line 612) | func ignoreScannerError(e *scanner.Error, s string) bool {
function key2name (line 650) | func key2name(name string) string {
function fixKey (line 654) | func fixKey(k string) string {
function doPrompt (line 738) | func doPrompt(out io.Writer) func(v reflect.Value) {
function getPrompt (line 748) | func getPrompt(in io.Reader, out io.Writer) func(reflect.Value) {
FILE: interp/interp_chan_test.go
type IntChan (line 11) | type IntChan
function NewIntChan (line 14) | func NewIntChan() IntChan {
function TestSendToBinaryChannelTypeAlias (line 18) | func TestSendToBinaryChannelTypeAlias(t *testing.T) {
function TestSendToSourceDefinedChannel (line 50) | func TestSendToSourceDefinedChannel(t *testing.T) {
function TestSendToSourceDefinedChannelTypeAlias (line 71) | func TestSendToSourceDefinedChannelTypeAlias(t *testing.T) {
FILE: interp/interp_consistent_test.go
function TestInterpConsistencyBuild (line 23) | func TestInterpConsistencyBuild(t *testing.T) {
function TestInterpErrorConsistency (line 205) | func TestInterpErrorConsistency(t *testing.T) {
FILE: interp/interp_eval_test.go
function init (line 27) | func init() { log.SetFlags(log.Lshortfile) }
type testCase (line 34) | type testCase struct
function TestEvalArithmetic (line 40) | func TestEvalArithmetic(t *testing.T) {
function TestEvalShift (line 76) | func TestEvalShift(t *testing.T) {
function TestOpVarConst (line 87) | func TestOpVarConst(t *testing.T) {
function TestEvalStar (line 98) | func TestEvalStar(t *testing.T) {
function TestEvalAssign (line 106) | func TestEvalAssign(t *testing.T) {
function TestEvalBuiltin (line 142) | func TestEvalBuiltin(t *testing.T) {
function TestEvalDecl (line 196) | func TestEvalDecl(t *testing.T) {
function TestEvalDeclWithExpr (line 208) | func TestEvalDeclWithExpr(t *testing.T) {
function TestEvalTypeSpec (line 217) | func TestEvalTypeSpec(t *testing.T) {
function TestEvalFunc (line 227) | func TestEvalFunc(t *testing.T) {
function TestEvalImport (line 240) | func TestEvalImport(t *testing.T) {
function TestEvalStdout (line 250) | func TestEvalStdout(t *testing.T) {
function TestEvalNil (line 266) | func TestEvalNil(t *testing.T) {
function TestEvalStruct0 (line 324) | func TestEvalStruct0(t *testing.T) {
function TestEvalStruct1 (line 372) | func TestEvalStruct1(t *testing.T) {
function TestEvalComposite0 (line 396) | func TestEvalComposite0(t *testing.T) {
function TestEvalCompositeBin0 (line 416) | func TestEvalCompositeBin0(t *testing.T) {
function TestEvalComparison (line 439) | func TestEvalComparison(t *testing.T) {
function TestEvalCompositeArray (line 484) | func TestEvalCompositeArray(t *testing.T) {
function TestEvalCompositeMap (line 500) | func TestEvalCompositeMap(t *testing.T) {
function TestEvalCompositeStruct (line 511) | func TestEvalCompositeStruct(t *testing.T) {
function TestEvalSliceExpression (line 531) | func TestEvalSliceExpression(t *testing.T) {
function TestEvalConversion (line 557) | func TestEvalConversion(t *testing.T) {
function TestEvalUnary (line 568) | func TestEvalUnary(t *testing.T) {
function TestEvalMethod (line 580) | func TestEvalMethod(t *testing.T) {
function TestEvalChan (line 619) | func TestEvalChan(t *testing.T) {
function TestEvalFunctionCallWithFunctionParam (line 653) | func TestEvalFunctionCallWithFunctionParam(t *testing.T) {
function TestEvalCall (line 672) | func TestEvalCall(t *testing.T) {
function TestEvalBinCall (line 715) | func TestEvalBinCall(t *testing.T) {
function TestEvalReflect (line 732) | func TestEvalReflect(t *testing.T) {
function TestEvalMissingSymbol (line 755) | func TestEvalMissingSymbol(t *testing.T) {
function TestEvalWithContext (line 783) | func TestEvalWithContext(t *testing.T) {
function runTests (line 879) | func runTests(t *testing.T, i *interp.Interpreter, tests []testCase) {
function eval (line 897) | func eval(t *testing.T, i *interp.Interpreter, src string) reflect.Value {
function assertEval (line 910) | func assertEval(t *testing.T, i *interp.Interpreter, src, expectedError,...
function TestMultiEval (line 935) | func TestMultiEval(t *testing.T) {
function TestMultiEvalNoName (line 983) | func TestMultiEvalNoName(t *testing.T) {
constant goMinorVersionTest (line 1017) | goMinorVersionTest = 16
function TestHasIOFS (line 1019) | func TestHasIOFS(t *testing.T) {
function TestImportPathIsKey (line 1097) | func TestImportPathIsKey(t *testing.T) {
function TestConcurrentEvals (line 1175) | func TestConcurrentEvals(t *testing.T) {
function TestConcurrentEvals2 (line 1236) | func TestConcurrentEvals2(t *testing.T) {
function TestConcurrentEvals3 (line 1299) | func TestConcurrentEvals3(t *testing.T) {
function TestConcurrentComposite1 (line 1374) | func TestConcurrentComposite1(t *testing.T) {
function TestConcurrentComposite2 (line 1378) | func TestConcurrentComposite2(t *testing.T) {
function testConcurrentComposite (line 1382) | func testConcurrentComposite(t *testing.T, filePath string) {
function TestEvalREPL (line 1426) | func TestEvalREPL(t *testing.T) {
type safeBuffer (line 1565) | type safeBuffer struct
method Read (line 1570) | func (sb *safeBuffer) Read(p []byte) (int, error) {
method String (line 1574) | func (sb *safeBuffer) String() string {
method Write (line 1580) | func (sb *safeBuffer) Write(p []byte) (int, error) {
constant CITimeoutMultiplier (line 1588) | CITimeoutMultiplier = 3
function Sleep (line 1592) | func Sleep(d time.Duration) {
function applyCIMultiplier (line 1597) | func applyCIMultiplier(timeout time.Duration) time.Duration {
function TestREPLCommands (line 1609) | func TestREPLCommands(t *testing.T) {
function TestStdio (line 1704) | func TestStdio(t *testing.T) {
function TestNoGoFiles (line 1719) | func TestNoGoFiles(t *testing.T) {
function TestIssue1142 (line 1729) | func TestIssue1142(t *testing.T) {
type Issue1149Array (line 1736) | type Issue1149Array
method Foo (line 1738) | func (v Issue1149Array) Foo() string { return "foo" }
method Bar (line 1739) | func (v *Issue1149Array) Bar() string { return "foo" }
function TestIssue1149 (line 1741) | func TestIssue1149(t *testing.T) {
function TestIssue1150 (line 1765) | func TestIssue1150(t *testing.T) {
function TestIssue1151 (line 1798) | func TestIssue1151(t *testing.T) {
function TestPassArgs (line 1819) | func TestPassArgs(t *testing.T) {
function TestRestrictedEnv (line 1830) | func TestRestrictedEnv(t *testing.T) {
function TestIssue1388 (line 1854) | func TestIssue1388(t *testing.T) {
function TestIssue1383 (line 1877) | func TestIssue1383(t *testing.T) {
function TestIssue1623 (line 1910) | func TestIssue1623(t *testing.T) {
FILE: interp/interp_export_test.go
type Helloer (line 10) | type Helloer interface
function Hi (line 14) | func Hi(h Helloer) {
type Wrap (line 36) | type Wrap struct
method Hello (line 41) | func (w Wrap) Hello() { w.DoHello() }
function TestExportsSemantics (line 43) | func TestExportsSemantics(t *testing.T) {
function TestInterface (line 79) | func TestInterface(t *testing.T) {
type T (line 108) | type T struct
method Bar (line 110) | func (t T) Bar(s ...string) {}
function TestCallBinVariadicMethod (line 112) | func TestCallBinVariadicMethod(t *testing.T) {
FILE: interp/interp_file_test.go
function TestFile (line 28) | func TestFile(t *testing.T) {
function runCheck (line 55) | func runCheck(t *testing.T, p string) {
function wantedFromComment (line 102) | func wantedFromComment(p string) (res string, goPath string, err bool) {
FILE: interp/interp_issue_1634_test.go
function TestExportClosureArg (line 11) | func TestExportClosureArg(t *testing.T) {
FILE: interp/interp_test.go
function init (line 12) | func init() { log.SetFlags(log.Lshortfile) }
function TestIsNatural (line 14) | func TestIsNatural(t *testing.T) {
function TestGlobals (line 195) | func TestGlobals(t *testing.T) {
FILE: interp/op.go
function add (line 13) | func add(n *node) {
function addConst (line 197) | func addConst(n *node) {
function and (line 222) | func and(n *node) {
function andConst (line 307) | func andConst(n *node) {
function andNot (line 326) | func andNot(n *node) {
function andNotConst (line 411) | func andNotConst(n *node) {
function mul (line 430) | func mul(n *node) {
function mulConst (line 583) | func mulConst(n *node) {
function or (line 606) | func or(n *node) {
function orConst (line 691) | func orConst(n *node) {
function quo (line 710) | func quo(n *node) {
function quoConst (line 863) | func quoConst(n *node) {
function rem (line 895) | func rem(n *node) {
function remConst (line 980) | func remConst(n *node) {
function shl (line 999) | func shl(n *node) {
function shlConst (line 1084) | func shlConst(n *node) {
function shr (line 1103) | func shr(n *node) {
function shrConst (line 1188) | func shrConst(n *node) {
function sub (line 1207) | func sub(n *node) {
function subConst (line 1360) | func subConst(n *node) {
function xor (line 1383) | func xor(n *node) {
function xorConst (line 1468) | func xorConst(n *node) {
function addAssign (line 1489) | func addAssign(n *node) {
function andAssign (line 1623) | func andAssign(n *node) {
function andNotAssign (line 1690) | func andNotAssign(n *node) {
function mulAssign (line 1757) | func mulAssign(n *node) {
function orAssign (line 1869) | func orAssign(n *node) {
function quoAssign (line 1936) | func quoAssign(n *node) {
function remAssign (line 2048) | func remAssign(n *node) {
function shlAssign (line 2115) | func shlAssign(n *node) {
function shrAssign (line 2182) | func shrAssign(n *node) {
function subAssign (line 2249) | func subAssign(n *node) {
function xorAssign (line 2361) | func xorAssign(n *node) {
function dec (line 2428) | func dec(n *node) {
function inc (line 2484) | func inc(n *node) {
function bitNotConst (line 2540) | func bitNotConst(n *node) {
function negConst (line 2559) | func negConst(n *node) {
function notConst (line 2582) | func notConst(n *node) {
function posConst (line 2598) | func posConst(n *node) {
function equal (line 2621) | func equal(n *node) {
function greater (line 3221) | func greater(n *node) {
function greaterEqual (line 3549) | func greaterEqual(n *node) {
function lower (line 3877) | func lower(n *node) {
function lowerEqual (line 4205) | func lowerEqual(n *node) {
function notEqual (line 4533) | func notEqual(n *node) {
FILE: interp/program.go
type Program (line 15) | type Program struct
method PackageName (line 22) | func (p *Program) PackageName() string {
method FileSet (line 28) | func (interp *Interpreter) FileSet() *token.FileSet {
method Compile (line 33) | func (interp *Interpreter) Compile(src string) (*Program, error) {
method CompilePath (line 38) | func (interp *Interpreter) CompilePath(path string) (*Program, error) {
method compileSrc (line 52) | func (interp *Interpreter) compileSrc(src, name string, inc bool) (*Prog...
method CompileAST (line 75) | func (interp *Interpreter) CompileAST(n ast.Node) (*Program, error) {
method Execute (line 142) | func (interp *Interpreter) Execute(p *Program) (res reflect.Value, err e...
method ExecuteWithContext (line 190) | func (interp *Interpreter) ExecuteWithContext(ctx context.Context, p *Pr...
FILE: interp/realfs.go
type realFS (line 12) | type realFS struct
method Open (line 15) | func (dir realFS) Open(name string) (fs.File, error) {
FILE: interp/run.go
type bltn (line 15) | type bltn
type bltnGenerator (line 18) | type bltnGenerator
function init (line 77) | func init() {
type valueInterface (line 86) | type valueInterface struct
function init (line 93) | func init() {
method run (line 98) | func (interp *Interpreter) run(n *node, cf *frame) {
function isExecNode (line 122) | func isExecNode(n *node, exec bltn) bool {
function originalExecNode (line 134) | func originalExecNode(n *node, exec bltn) *node {
function panicFunc (line 183) | func panicFunc(s *scope) string {
function runCfg (line 205) | func runCfg(n *node, f *frame, funcNode, callNode *node) {
function stripReceiverFromArgs (line 272) | func stripReceiverFromArgs(signature string) (string, error) {
function typeAssertShort (line 283) | func typeAssertShort(n *node) {
function typeAssertLong (line 287) | func typeAssertLong(n *node) {
function typeAssertStatus (line 291) | func typeAssertStatus(n *node) {
function typeAssert (line 295) | func typeAssert(n *node, withResult, withOk bool) {
function canAssertTypes (line 556) | func canAssertTypes(src, dest reflect.Type) bool {
function firstMissingMethod (line 575) | func firstMissingMethod(src, dest reflect.Type) string {
function convert (line 585) | func convert(n *node) {
function assignFromCall (line 639) | func assignFromCall(n *node) {
function assign (line 675) | func assign(n *node) {
function not (line 795) | func not(n *node) {
function addr (line 818) | func addr(n *node) {
function deref (line 840) | func deref(n *node) {
function _print (line 864) | func _print(n *node) {
function _println (line 883) | func _println(n *node) {
function _recover (line 903) | func _recover(n *node) {
function _panic (line 927) | func _panic(n *node) {
function genBuiltinDeferWrapper (line 935) | func genBuiltinDeferWrapper(n *node, in, out []func(*frame) reflect.Valu...
function genFunctionWrapper (line 974) | func genFunctionWrapper(n *node) func(*frame) reflect.Value {
function genInterfaceWrapper (line 1062) | func genInterfaceWrapper(n *node, typ reflect.Type) func(*frame) reflect...
function methodByName (line 1145) | func methodByName(value reflect.Value, name string, index []int) (v refl...
function checkFieldIndex (line 1166) | func checkFieldIndex(typ reflect.Type, index []int) bool {
function call (line 1187) | func call(n *node) {
function getFrame (line 1431) | func getFrame(f *frame, l int) *frame {
function callBin (line 1449) | func callBin(n *node) {
function getIndexBinMethod (line 1692) | func getIndexBinMethod(n *node) {
function getIndexBinElemMethod (line 1708) | func getIndexBinElemMethod(n *node) {
function getIndexBinPtrMethod (line 1722) | func getIndexBinPtrMethod(n *node) {
function getIndexArray (line 1737) | func getIndexArray(n *node) {
function getIndexMap (line 1786) | func getIndexMap(n *node) {
function getIndexMap2 (line 1844) | func getIndexMap2(n *node) {
function getFunc (line 1902) | func getFunc(n *node) {
function getMethod (line 1956) | func getMethod(n *node) {
function getMethodByName (line 1970) | func getMethodByName(n *node) {
function lookupMethodValue (line 2046) | func lookupMethodValue(val valueInterface, name string) (r reflect.Value...
function getIndexSeq (line 2074) | func getIndexSeq(n *node) {
function getPtrIndexSeq (line 2111) | func getPtrIndexSeq(n *node) {
function getIndexSeqField (line 2136) | func getIndexSeqField(n *node) {
function getIndexSeqPtrMethod (line 2179) | func getIndexSeqPtrMethod(n *node) {
function getIndexSeqMethod (line 2215) | func getIndexSeqMethod(n *node) {
function neg (line 2251) | func neg(n *node) {
function pos (line 2310) | func pos(n *node) {
function bitNot (line 2321) | func bitNot(n *node) {
function land (line 2356) | func land(n *node) {
function lor (line 2389) | func lor(n *node) {
function nop (line 2422) | func nop(n *node) {
function branch (line 2430) | func branch(n *node) {
function _return (line 2443) | func _return(n *node) {
function arrayLit (line 2519) | func arrayLit(n *node) {
function mapLit (line 2563) | func mapLit(n *node) {
function compositeBinMap (line 2588) | func compositeBinMap(n *node) {
function compositeBinSlice (line 2620) | func compositeBinSlice(n *node) {
function doCompositeBinStruct (line 2667) | func doCompositeBinStruct(n *node, hasType bool) {
function compositeBinStruct (line 2719) | func compositeBinStruct(n *node) { doCompositeBinStruct(n, true) }
function compositeBinStructNotype (line 2720) | func compositeBinStructNotype(n *node) { doCompositeBinStruct(n, false) }
function destType (line 2722) | func destType(n *node) *itype {
function doComposite (line 2731) | func doComposite(n *node, hasType bool, keyed bool) {
function doCompositeLit (line 2796) | func doCompositeLit(n *node, hasType bool) {
function compositeLit (line 2800) | func compositeLit(n *node) { doCompositeLit(n, true) }
function compositeLitNotype (line 2801) | func compositeLitNotype(n *node) { doCompositeLit(n, false) }
function doCompositeLitKeyed (line 2804) | func doCompositeLitKeyed(n *node, hasType bool) {
function compositeLitKeyed (line 2808) | func compositeLitKeyed(n *node) { doCompositeLitKeyed(n, true) }
function compositeLitKeyedNotype (line 2809) | func compositeLitKeyedNotype(n *node) { doCompositeLitKeyed(n, false) }
function empty (line 2811) | func empty(n *node) {}
function _range (line 2815) | func _range(n *node) {
function rangeInt (line 2890) | func rangeInt(n *node) {
function loopVarKey (line 2919) | func loopVarKey(n *node) {
function loopVarVal (line 2931) | func loopVarVal(n *node) {
function loopVarFor (line 2943) | func loopVarFor(n *node) {
function rangeChan (line 2955) | func rangeChan(n *node) {
function rangeMap (line 2978) | func rangeMap(n *node) {
function _case (line 3015) | func _case(n *node) {
function implementsInterface (line 3213) | func implementsInterface(v reflect.Value, t *itype) bool {
function appendSlice (line 3229) | func appendSlice(n *node) {
function _append (line 3249) | func _append(n *node) {
function _cap (line 3315) | func _cap(n *node) {
function _copy (line 3333) | func _copy(n *node) {
function _close (line 3343) | func _close(n *node) {
function _complex (line 3352) | func _complex(n *node) {
function _imag (line 3383) | func _imag(n *node) {
function _real (line 3402) | func _real(n *node) {
function _delete (line 3421) | func _delete(n *node) {
function capConst (line 3433) | func capConst(n *node) {
function lenConst (line 3438) | func lenConst(n *node) {
function _len (line 3452) | func _len(n *node) {
function _new (line 3480) | func _new(n *node) {
function _make (line 3501) | func _make(n *node) {
function reset (line 3557) | func reset(n *node) {
function recv (line 3594) | func recv(n *node) {
function recv2 (line 3670) | func recv2(n *node) {
function convertLiteralValue (line 3710) | func convertLiteralValue(n *node, t reflect.Type) {
function convertConstantValue (line 3727) | func convertConstantValue(n *node) {
function send (line 3762) | func send(n *node) {
function clauseChanDir (line 3797) | func clauseChanDir(n *node) (*node, *node, *node, reflect.SelectDir) {
function _select (line 3826) | func _select(n *node) {
function slice (line 3907) | func slice(n *node) {
function slice0 (line 3942) | func slice0(n *node) {
function isNilChild (line 3973) | func isNilChild(child int) func(n *node) {
function isNotNil (line 4059) | func isNotNil(n *node) {
function complexConst (line 4145) | func complexConst(n *node) {
function imagConst (line 4152) | func imagConst(n *node) {
function realConst (line 4159) | func realConst(n *node) {
FILE: interp/scope.go
type sKind (line 10) | type sKind
method String (line 39) | func (k sKind) String() string {
constant undefSym (line 14) | undefSym sKind = iota
constant binSym (line 15) | binSym
constant bltnSym (line 16) | bltnSym
constant constSym (line 17) | constSym
constant funcSym (line 18) | funcSym
constant labelSym (line 19) | labelSym
constant pkgSym (line 20) | pkgSym
constant typeSym (line 21) | typeSym
constant varTypeSym (line 22) | varTypeSym
constant varSym (line 23) | varSym
type symbol (line 48) | type symbol struct
type scope (line 75) | type scope struct
method push (line 91) | func (s *scope) push(indirect bool) *scope {
method pushBloc (line 109) | func (s *scope) pushBloc() *scope { return s.push(false) }
method pushFunc (line 110) | func (s *scope) pushFunc() *scope { return s.push(true) }
method pop (line 112) | func (s *scope) pop() *scope {
method upperLevel (line 120) | func (s *scope) upperLevel() *scope {
method lookup (line 131) | func (s *scope) lookup(ident string) (*symbol, int, bool) {
method isRedeclared (line 148) | func (s *scope) isRedeclared(n *node) bool {
method rangeChanType (line 156) | func (s *scope) rangeChanType(n *node) *itype {
method fixType (line 185) | func (s *scope) fixType(t *itype) *itype {
method getType (line 202) | func (s *scope) getType(ident string) *itype {
method add (line 213) | func (s *scope) add(typ *itype) (index int) {
method initScopePkg (line 226) | func (interp *Interpreter) initScopePkg(pkgID, pkgName string) *scope {
method Globals (line 241) | func (interp *Interpreter) Globals() map[string]reflect.Value {
FILE: interp/self_example_test.go
function ExampleInterpreter_self (line 10) | func ExampleInterpreter_self() {
FILE: interp/src.go
method importSrc (line 15) | func (interp *Interpreter) importSrc(rPath, importPath string, skipTest ...
method rootFromSourceLocation (line 179) | func (interp *Interpreter) rootFromSourceLocation() (string, error) {
method pkgDir (line 205) | func (interp *Interpreter) pkgDir(goPath string, root, importPath string...
constant vendor (line 235) | vendor = "vendor"
function previousRoot (line 238) | func previousRoot(filesystem fs.FS, rootPath, root string) (string, erro...
function effectivePkg (line 303) | func effectivePkg(root, p string) string {
function isPathRelative (line 333) | func isPathRelative(s string) bool {
FILE: interp/src_test.go
function Test_effectivePkg (line 10) | func Test_effectivePkg(t *testing.T) {
function Test_pkgDir (line 51) | func Test_pkgDir(t *testing.T) {
function Test_previousRoot (line 200) | func Test_previousRoot(t *testing.T) {
FILE: interp/testdata/concurrent/composite/composite_lit.go
type foo (line 7) | type foo struct
function main (line 11) | func main() {
FILE: interp/testdata/concurrent/composite/composite_sparse.go
type foo (line 7) | type foo struct
function main (line 11) | func main() {
FILE: interp/testdata/concurrent/hello1.go
function main (line 5) | func main() {
FILE: interp/testdata/concurrent/hello2.go
function main (line 5) | func main() {
FILE: interp/testdata/multi/731/sample1.go
function PrintA (line 5) | func PrintA() {
FILE: interp/testdata/multi/731/sample2.go
function PrintB (line 5) | func PrintB() {
FILE: interp/testdata/multi/731/sample3.go
function main (line 5) | func main() {
FILE: interp/trace.go
function traceIndent (line 12) | func traceIndent(n *node) string {
function tracePrintln (line 18) | func tracePrintln(n *node, v ...any) {
function tracePrintTree (line 29) | func tracePrintTree(n *node, v ...any) {
function ptrAddr (line 41) | func ptrAddr(v any) string {
function valString (line 49) | func valString(v reflect.Value) string {
method String (line 59) | func (n *node) String() string {
method depth (line 85) | func (n *node) depth() int {
method String (line 92) | func (sy *symbol) String() string {
method String (line 109) | func (t *itype) String() string {
FILE: interp/type.go
type tcat (line 15) | type tcat
method String (line 101) | func (c tcat) String() string {
constant nilT (line 19) | nilT tcat = iota
constant arrayT (line 20) | arrayT
constant binT (line 21) | binT
constant binPkgT (line 22) | binPkgT
constant boolT (line 23) | boolT
constant builtinT (line 24) | builtinT
constant chanT (line 25) | chanT
constant chanSendT (line 26) | chanSendT
constant chanRecvT (line 27) | chanRecvT
constant comparableT (line 28) | comparableT
constant complex64T (line 29) | complex64T
constant complex128T (line 30) | complex128T
constant constraintT (line 31) | constraintT
constant errorT (line 32) | errorT
constant float32T (line 33) | float32T
constant float64T (line 34) | float64T
constant funcT (line 35) | funcT
constant genericT (line 36) | genericT
constant interfaceT (line 37) | interfaceT
constant intT (line 38) | intT
constant int8T (line 39) | int8T
constant int16T (line 40) | int16T
constant int32T (line 41) | int32T
constant int64T (line 42) | int64T
constant linkedT (line 43) | linkedT
constant mapT (line 44) | mapT
constant ptrT (line 45) | ptrT
constant sliceT (line 46) | sliceT
constant srcPkgT (line 47) | srcPkgT
constant stringT (line 48) | stringT
constant structT (line 49) | structT
constant uintT (line 50) | uintT
constant uint8T (line 51) | uint8T
constant uint16T (line 52) | uint16T
constant uint32T (line 53) | uint32T
constant uint64T (line 54) | uint64T
constant uintptrT (line 55) | uintptrT
constant valueT (line 56) | valueT
constant variadicT (line 57) | variadicT
constant maxT (line 58) | maxT
type structField (line 109) | type structField struct
type itype (line 117) | type itype struct
method finalize (line 1268) | func (t *itype) finalize() (*itype, error) {
method addMethod (line 1294) | func (t *itype) addMethod(n *node) {
method numIn (line 1303) | func (t *itype) numIn() int {
method in (line 1320) | func (t *itype) in(i int) *itype {
method numOut (line 1339) | func (t *itype) numOut() int {
method out (line 1356) | func (t *itype) out(i int) *itype {
method concrete (line 1368) | func (t *itype) concrete() *itype {
method underlying (line 1375) | func (t *itype) underlying() *itype {
method isVariadic (line 1396) | func (t *itype) isVariadic() bool {
method isComplete (line 1409) | func (t *itype) isComplete() bool { return isComplete(t, map[string]bo...
method comparable (line 1457) | func (t *itype) comparable() bool {
method assignableTo (line 1462) | func (t *itype) assignableTo(o *itype) bool {
method convertibleTo (line 1512) | func (t *itype) convertibleTo(o *itype) bool {
method ordered (line 1530) | func (t *itype) ordered() bool {
method equals (line 1536) | func (t *itype) equals(o *itype) bool {
method matchDefault (line 1550) | func (t *itype) matchDefault(o *itype) bool {
method methods (line 1576) | func (t *itype) methods() methodSet {
method id (line 1644) | func (t *itype) id() (res string) {
method zero (line 1676) | func (t *itype) zero() (v reflect.Value, err error) {
method fieldIndex (line 1697) | func (t *itype) fieldIndex(name string) int {
method fieldSeq (line 1711) | func (t *itype) fieldSeq(seq []int) *itype {
method lookupField (line 1720) | func (t *itype) lookupField(name string) []int {
method lookupBinField (line 1760) | func (t *itype) lookupBinField(name string) (s reflect.StructField, in...
method methodCallType (line 1790) | func (t *itype) methodCallType() reflect.Type {
method resolveAlias (line 1804) | func (t *itype) resolveAlias() *itype {
method getMethod (line 1812) | func (t *itype) getMethod(name string) *node {
method lookupMethod (line 1823) | func (t *itype) lookupMethod(name string) (*node, []int) {
method lookupMethod2 (line 1827) | func (t *itype) lookupMethod2(name string, seen map[*itype]bool) (*nod...
method interfaceMethod (line 1857) | func (t *itype) interfaceMethod(name string) *itype {
method interfaceMethod2 (line 1861) | func (t *itype) interfaceMethod2(name string, seen map[*itype]bool) *i...
method methodDepth (line 1890) | func (t *itype) methodDepth(name string) int {
method lookupBinMethod (line 1901) | func (t *itype) lookupBinMethod(name string) (m reflect.Method, index ...
method lookupBinMethod2 (line 1905) | func (t *itype) lookupBinMethod2(name string, seen map[*itype]bool) (m...
method fixDummy (line 2008) | func (t *itype) fixDummy(typ reflect.Type) reflect.Type {
method refType (line 2052) | func (t *itype) refType(ctx *refTypeContext) reflect.Type {
method TypeOf (line 2216) | func (t *itype) TypeOf() reflect.Type {
method frameType (line 2220) | func (t *itype) frameType() (r reflect.Type) {
method implements (line 2249) | func (t *itype) implements(it *itype) bool {
method defaultType (line 2265) | func (t *itype) defaultType(v reflect.Value, sc *scope) *itype {
method isNil (line 2311) | func (t *itype) isNil() bool { return t.cat == nilT }
method hasNil (line 2313) | func (t *itype) hasNil() bool {
method elem (line 2327) | func (t *itype) elem() *itype {
type generic (line 142) | type generic struct
function untypedBool (line 144) | func untypedBool(n *node) *itype {
function untypedString (line 148) | func untypedString(n *node) *itype {
function untypedRune (line 152) | func untypedRune(n *node) *itype {
function untypedInt (line 156) | func untypedInt(n *node) *itype {
function untypedFloat (line 160) | func untypedFloat(n *node) *itype {
function untypedComplex (line 164) | func untypedComplex(n *node) *itype {
function errorMethodType (line 168) | func errorMethodType(sc *scope) *itype {
type itypeOption (line 172) | type itypeOption
function isBinMethod (line 174) | func isBinMethod() itypeOption {
function withRecv (line 180) | func withRecv(typ *itype) itypeOption {
function withNode (line 186) | func withNode(n *node) itypeOption {
function withScope (line 192) | func withScope(sc *scope) itypeOption {
function withUntyped (line 198) | func withUntyped(b bool) itypeOption {
function valueTOf (line 205) | func valueTOf(rtype reflect.Type, opts ...itypeOption) *itype {
function wrapperValueTOf (line 217) | func wrapperValueTOf(rtype reflect.Type, val *itype, opts ...itypeOption...
function variadicOf (line 225) | func variadicOf(val *itype, opts ...itypeOption) *itype {
function ptrOf (line 234) | func ptrOf(val *itype, opts ...itypeOption) *itype {
function namedOf (line 247) | func namedOf(val *itype, path, name string, opts ...itypeOption) *itype {
function funcOf (line 260) | func funcOf(args []*itype, ret []*itype, opts ...itypeOption) *itype {
type chanDir (line 283) | type chanDir
constant chanSendRecv (line 286) | chanSendRecv chanDir = iota
constant chanSend (line 287) | chanSend
constant chanRecv (line 288) | chanRecv
function chanOf (line 292) | func chanOf(val *itype, dir chanDir, opts ...itypeOption) *itype {
function arrayOf (line 311) | func arrayOf(val *itype, l int, opts ...itypeOption) *itype {
function sliceOf (line 321) | func sliceOf(val *itype, opts ...itypeOption) *itype {
function mapOf (line 330) | func mapOf(key, val *itype, opts ...itypeOption) *itype {
function interfaceOf (line 339) | func interfaceOf(t *itype, fields []structField, constraint, ulconstrain...
function structOf (line 359) | func structOf(t *itype, fields []structField, opts ...itypeOption) *itype {
function genericOf (line 377) | func genericOf(val *itype, name, path string, opts ...itypeOption) *itype {
function seenNode (line 389) | func seenNode(ns []*node, n *node) bool {
function nodeType (line 399) | func nodeType(interp *Interpreter, sc *scope, n *node) (*itype, error) {
function nodeType2 (line 403) | func nodeType2(interp *Interpreter, sc *scope, n *node, seen []*node) (t...
function genType (line 1130) | func genType(interp *Interpreter, sc *scope, name string, lt *itype, typ...
function genMethod (line 1155) | func genMethod(interp *Interpreter, sc *scope, t *itype, nod *node, type...
function findPackageType (line 1183) | func findPackageType(interp *Interpreter, sc *scope, n *node) *itype {
function isBuiltinCall (line 1197) | func isBuiltinCall(n *node, sc *scope) bool {
function typeName (line 1211) | func typeName(n *node) string {
function structName (line 1218) | func structName(n *node) string {
function fieldName (line 1226) | func fieldName(n *node) string {
function init (line 1243) | func init() {
function typeDefined (line 1383) | func typeDefined(t1, t2 *itype) bool {
function isComplete (line 1411) | func isComplete(t *itype, visited map[string]bool) bool {
type methodSet (line 1555) | type methodSet
method contains (line 1558) | func (m methodSet) contains(n methodSet) bool {
method equals (line 1571) | func (m methodSet) equals(n methodSet) bool {
function fixPossibleConstType (line 1655) | func fixPossibleConstType(t reflect.Type) (r reflect.Type) {
function lookupFieldOrMethod (line 1932) | func lookupFieldOrMethod(t *itype, name string) *itype {
function exportName (line 1962) | func exportName(s string) string {
type refTypeContext (line 1976) | type refTypeContext struct
method Clone (line 1995) | func (c *refTypeContext) Clone() *refTypeContext {
method isComplete (line 1999) | func (c *refTypeContext) isComplete() bool {
function hasElem (line 2334) | func hasElem(t reflect.Type) bool {
function constToInt (line 2342) | func constToInt(c constant.Value) int {
function constToString (line 2350) | func constToString(v reflect.Value) string {
function wrappedType (line 2355) | func wrappedType(n *node) *itype {
function isShiftNode (line 2362) | func isShiftNode(n *node) bool {
function chanElement (line 2371) | func chanElement(t *itype) *itype {
function isBool (line 2383) | func isBool(t *itype) bool { return t.TypeOf().Kind() == reflect.Bool }
function isChan (line 2384) | func isChan(t *itype) bool { return t.TypeOf().Kind() == reflect.Chan }
function isFunc (line 2385) | func isFunc(t *itype) bool { return t.TypeOf().Kind() == reflect.Func }
function isMap (line 2386) | func isMap(t *itype) bool { return t.TypeOf().Kind() == reflect.Map }
function isPtr (line 2387) | func isPtr(t *itype) bool { return t.TypeOf().Kind() == reflect.Ptr }
function isEmptyInterface (line 2389) | func isEmptyInterface(t *itype) bool {
function isGeneric (line 2393) | func isGeneric(t *itype) bool {
function isNamedFuncSrc (line 2397) | func isNamedFuncSrc(t *itype) bool {
function isFuncSrc (line 2401) | func isFuncSrc(t *itype) bool {
function isPtrSrc (line 2405) | func isPtrSrc(t *itype) bool {
function isSendChan (line 2409) | func isSendChan(t *itype) bool {
function isArray (line 2414) | func isArray(t *itype) bool {
function isInterfaceSrc (line 2422) | func isInterfaceSrc(t *itype) bool {
function isInterfaceBin (line 2426) | func isInterfaceBin(t *itype) bool {
function isInterface (line 2430) | func isInterface(t *itype) bool {
function isBin (line 2434) | func isBin(t *itype) bool {
function isStruct (line 2445) | func isStruct(t *itype) bool {
function isConstType (line 2461) | func isConstType(t *itype) bool {
function isInt (line 2466) | func isInt(t reflect.Type) bool {
function isUint (line 2477) | func isUint(t reflect.Type) bool {
function isComplex (line 2488) | func isComplex(t reflect.Type) bool {
function isFloat (line 2499) | func isFloat(t reflect.Type) bool {
function isByteArray (line 2510) | func isByteArray(t reflect.Type) bool {
function isFloat32 (line 2518) | func isFloat32(t reflect.Type) bool { return t != nil && t.Kind() == ref...
function isFloat64 (line 2519) | func isFloat64(t reflect.Type) bool { return t != nil && t.Kind() == ref...
function isNumber (line 2520) | func isNumber(t reflect.Type) bool {
function isBoolean (line 2523) | func isBoolean(t reflect.Type) bool { return t != nil && t.Kind() ...
function isString (line 2524) | func
Copy disabled (too large)
Download .json
Condensed preview — 1654 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (20,729K chars).
[
{
"path": ".github/ISSUE_TEMPLATE/bug_report.yml",
"chars": 1425,
"preview": "name: Bug Report\ndescription: Create a report to help us improve\n\nbody:\n - type: markdown\n attributes:\n value: "
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 337,
"preview": "blank_issues_enabled: false\ncontact_links:\n - name: Questions\n url: https://community.traefik.io/c/yaegi\n about: "
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.yml",
"chars": 878,
"preview": "name: Feature request\ndescription: Propose a change to Yaegi\n\nbody:\n - type: markdown\n attributes:\n value: |\n "
},
{
"path": ".github/workflows/go-cross.yml",
"chars": 1452,
"preview": "name: Build Cross OS\n\non:\n push:\n branches:\n - master\n pull_request:\n\njobs:\n\n cross:\n name: Go\n runs-on"
},
{
"path": ".github/workflows/main.yml",
"chars": 3126,
"preview": "name: Main\n\non:\n push:\n branches:\n - master\n pull_request:\n\nenv:\n GO_VERSION: stable\n GOLANGCI_LINT_VERSION:"
},
{
"path": ".github/workflows/release.yml",
"chars": 769,
"preview": "name: Release\n\non:\n push:\n tags:\n - v[0-9]+.[0-9]+*\n\nenv:\n GO_VERSION: stable\n\njobs:\n\n release:\n name: Cre"
},
{
"path": ".gitignore",
"chars": 114,
"preview": ".*.swo\n.*.swp\n*.dot\n*.out\n.idea/\n/yaegi\ninternal/cmd/extract/extract\nexample/inception/inception\n_test/tmp/\n/dist\n"
},
{
"path": ".golangci.yml",
"chars": 1487,
"preview": "version: \"2\"\nlinters:\n default: standard\n enable:\n - depguard\n - goconst\n - godot\n - grouper\n - misspel"
},
{
"path": ".goreleaser.yml",
"chars": 1210,
"preview": "project_name: yaegi\n\nbuilds:\n - id: yaegi\n binary: yaegi\n main: ./cmd/yaegi/\n\n goos:\n - darwin\n - li"
},
{
"path": "CONTRIBUTING.md",
"chars": 1169,
"preview": "# Contributing\n\nYaegi is an open source project, and your feedback and contributions\nare needed and always welcome.\n\n[Is"
},
{
"path": "LICENSE",
"chars": 11379,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "Makefile",
"chars": 1336,
"preview": "# Static linting of source files. See .golangci.toml for options\ncheck:\n\tgolangci-lint run\n\n# Generate stdlib/syscall/sy"
},
{
"path": "README.md",
"chars": 5399,
"preview": "<p align=\"center\">\n<img width=\"400\" src=\"doc/images/yaegi.png\" alt=\"Yaegi\" title=\"Yaegi\" />\n</p>\n\n[![release](https://im"
},
{
"path": "_test/a1.go",
"chars": 184,
"preview": "package main\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tprintln(a[1]) // 2\n\tfor i, v := range a {\n\t\tprintln(v)\n\t\tif "
},
{
"path": "_test/a10.go",
"chars": 213,
"preview": "package main\n\ntype Sample struct {\n\tName string\n}\n\nvar samples = []Sample{}\n\nfunc f(i int) {\n\tprintln(samples[i].Name)\n}"
},
{
"path": "_test/a11.go",
"chars": 125,
"preview": "package main\n\nfunc main() {\n\ta := []int{1, 2, 3, 4}\n\tfor _, v := range a {\n\t\tprintln(v)\n\t}\n}\n\n// Output:\n// 1\n// 2\n// 3\n"
},
{
"path": "_test/a12.go",
"chars": 99,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar buf [12]int\n\tfmt.Println(buf[0])\n}\n\n// Output:\n// 0\n"
},
{
"path": "_test/a13.go",
"chars": 165,
"preview": "package main\n\ntype T1 struct {\n\tnum []int\n}\n\nfunc main() {\n\ta := T1{[]int{1, 3, 5}}\n\tfor i, v := range a.num {\n\t\tprintln"
},
{
"path": "_test/a14.go",
"chars": 139,
"preview": "package main\n\nimport \"fmt\"\n\nconst size = 12\n\nfunc main() {\n\tvar buf [size]int\n\tfmt.Println(buf)\n}\n\n// Output:\n// [0 0 0 "
},
{
"path": "_test/a15.go",
"chars": 142,
"preview": "package main\n\nimport \"fmt\"\n\nconst size = 12\n\nfunc main() {\n\tvar buf [size]int\n\tfmt.Println(buf[:])\n}\n\n// Output:\n// [0 0"
},
{
"path": "_test/a16.go",
"chars": 239,
"preview": "package main\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tprintln(a[1]) // 2\n\tfor k := 0; k < 2; k++ {\n\t\tfor i, v := r"
},
{
"path": "_test/a17.go",
"chars": 125,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := make([]int, 2, 7)\n\tfmt.Println(a, len(a), cap(a))\n}\n\n// Output:\n// [0 0]"
},
{
"path": "_test/a18.go",
"chars": 127,
"preview": "package main\n\nfunc main() {\n\ta := []int64{1, 2, 3, 4}\n\tfor _, v := range a {\n\t\tprintln(v)\n\t}\n}\n\n// Output:\n// 1\n// 2\n// "
},
{
"path": "_test/a19.go",
"chars": 106,
"preview": "package main\n\nfunc main() {\n\tvar buf [bsize]byte\n\tprintln(len(buf))\n}\n\nconst bsize = 10\n\n// Output:\n// 10\n"
},
{
"path": "_test/a2.go",
"chars": 194,
"preview": "package main\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\ta[1] = 5\n\tprintln(a[1]) // 2\n\tfor i, v := range a {\n\t\tprintl"
},
{
"path": "_test/a20.go",
"chars": 183,
"preview": "package main\n\nimport \"fmt\"\n\ntype IntArray []int\n\nfunc (h *IntArray) Add(x int) {\n\t*h = append(*h, x)\n}\n\nfunc main() {\n\ta"
},
{
"path": "_test/a21.go",
"chars": 183,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := []byte(\"hello\")\n\tfmt.Println(a)\n\ta = append(a, '=')\n\tfmt.Println(a)\n}\n\n/"
},
{
"path": "_test/a22.go",
"chars": 107,
"preview": "package main\n\nfunc main() {\n\ta := [256]int{}\n\tvar b uint8 = 12\n\ta[b] = 1\n\tprintln(a[b])\n}\n\n// Output:\n// 1\n"
},
{
"path": "_test/a23.go",
"chars": 378,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar key, salt [32]byte\n\tfor i := range key {\n\t\tkey[i] = byte(i)\n\t\tsalt[i] = b"
},
{
"path": "_test/a24.go",
"chars": 307,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfor i := 0; i < 2; i++ {\n\t\tvar buf [8]byte\n\t\tvar x int\n\t\tfmt.Println(buf, x)\n"
},
{
"path": "_test/a25.go",
"chars": 214,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar buf [8]byte\n\tfor i := 0; i < 2; i++ {\n\t\tfor i := range buf {\n\t\t\tbuf[i] +="
},
{
"path": "_test/a26.go",
"chars": 111,
"preview": "package main\n\nfunc main() {\n\ta := [3]int{1, 2, 3}\n\tb := [3]int{1, 2, 3}\n\tprintln(a == b)\n}\n\n// Output:\n// true\n"
},
{
"path": "_test/a27.go",
"chars": 148,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]string{\"hello\", \"world\"}\n\tfmt.Printf(\"%v %T\\n\", a, a)\n}\n\n// Output:"
},
{
"path": "_test/a28.go",
"chars": 146,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]string{9: \"hello\"}\n\tfmt.Printf(\"%v %T\\n\", a, a)\n}\n\n// Output:\n// [ "
},
{
"path": "_test/a29.go",
"chars": 269,
"preview": "package main\n\nimport \"fmt\"\n\nconst (\n\tzero = iota\n\tone\n\ttwo\n\tthree\n)\n\nfunc main() {\n\ta := [...]string{\n\t\tzero: \"zero"
},
{
"path": "_test/a3.go",
"chars": 120,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tfmt.Println(a[2:])\n}\n\n// Output:\n// [3 4 5 6]\n"
},
{
"path": "_test/a30.go",
"chars": 92,
"preview": "package main\n\nfunc main() {\n\tfor range []struct{}{} {\n\t}\n\tprintln(\"ok\")\n}\n\n// Output:\n// ok\n"
},
{
"path": "_test/a31.go",
"chars": 125,
"preview": "package main\n\nfunc main() {\n\tfor range []int{0, 1, 2} {\n\t\tprint(\"hello \")\n\t}\n\tprintln(\"\")\n}\n\n// Output:\n// hello hello h"
},
{
"path": "_test/a32.go",
"chars": 114,
"preview": "package main\n\nimport \"fmt\"\n\ntype T struct{}\n\nvar a = []T{{}}\n\nfunc main() {\n\tfmt.Println(a)\n}\n\n// Output:\n// [{}]\n"
},
{
"path": "_test/a33.go",
"chars": 115,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]int{1, 2, 3}\n\tb := a\n\tfmt.Println(b)\n}\n\n// Output:\n// [1 2 3]\n"
},
{
"path": "_test/a34.go",
"chars": 125,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]int{1, 2, 3}\n\tvar b [3]int = a\n\tfmt.Println(b)\n}\n\n// Output:\n// [1 "
},
{
"path": "_test/a35.go",
"chars": 126,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]int{1, 2, 3}\n\tb := a\n\tb[0] = -1\n\tfmt.Println(a)\n}\n\n// Output:\n// [1"
},
{
"path": "_test/a36.go",
"chars": 136,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]int{1, 2, 3}\n\tvar b [3]int = a\n\tb[0] = -1\n\tfmt.Println(a)\n}\n\n// Out"
},
{
"path": "_test/a37.go",
"chars": 107,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]int{1, 2, 3}\n\tfmt.Println(a)\n}\n\n// Output:\n// [1 2 3]\n"
},
{
"path": "_test/a38.go",
"chars": 109,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]byte{}\n\tfmt.Printf(\"%T\\n\", a)\n}\n\n// Output:\n// [0]uint8\n"
},
{
"path": "_test/a39.go",
"chars": 132,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [...]byte{}\n\tb := a\n\tfmt.Printf(\"%T %T\\n\", a, b)\n}\n\n// Output:\n// [0]uin"
},
{
"path": "_test/a4.go",
"chars": 117,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tfmt.Println(a[2:4])\n}\n\n// Output:\n// [3 4]\n"
},
{
"path": "_test/a40.go",
"chars": 172,
"preview": "package main\n\nimport \"fmt\"\n\ntype rule uint8\n\nconst (\n\tr0 rule = iota\n\tr1\n\tr2\n)\n\nvar a = [...]int{\n\tr0: 1,\n\tr1: 12,\n}\n\nfu"
},
{
"path": "_test/a41.go",
"chars": 104,
"preview": "package main\n\nvar a = [...]bool{true, true}\n\nfunc main() {\n\tprintln(a[0] && true)\n}\n\n// Output:\n// true\n"
},
{
"path": "_test/a42.go",
"chars": 181,
"preview": "package main\n\nimport (\n\t\"encoding/binary\"\n\t\"fmt\"\n)\n\nfunc main() {\n\tvar b [8]byte\n\tbinary.LittleEndian.PutUint64(b[:], ui"
},
{
"path": "_test/a43.go",
"chars": 137,
"preview": "package main\n\nimport \"fmt\"\n\ntype T [l1 + l2]int\n\nconst (\n\tl1 = 2\n\tl2 = 3\n)\n\nfunc main() {\n\tfmt.Println(T{})\n}\n\n// Output"
},
{
"path": "_test/a44.go",
"chars": 101,
"preview": "package main\n\nvar a = [max]int{}\n\nconst max = 32\n\nfunc main() {\n\tprintln(len(a))\n}\n\n// Output:\n// 32\n"
},
{
"path": "_test/a5.go",
"chars": 120,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tfmt.Println(a[:4])\n}\n\n// Output:\n// [1 2 3 4]\n"
},
{
"path": "_test/a6.go",
"chars": 123,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tfmt.Println(a[:])\n}\n\n// Output:\n// [1 2 3 4 5 "
},
{
"path": "_test/a7.go",
"chars": 113,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := [6]int{1, 2, 3, 4, 5, 6}\n\tfmt.Println(len(a))\n}\n\n// Output:\n// 6\n"
},
{
"path": "_test/a8.go",
"chars": 146,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\t//a := []int{1, 2}\n\ta := make([]int, 2)\n\t//a[0] = 1\n\t//a[1] = 2\n\tfmt.Println("
},
{
"path": "_test/a9.go",
"chars": 187,
"preview": "package main\n\nimport \"fmt\"\n\n//var (\n//\tsamples = []int{}\n//\tb = 1\n//)\n\nfunc main() {\n\tvar samples = []int{}\n\tsampl"
},
{
"path": "_test/add0.go",
"chars": 92,
"preview": "package main\n\nfunc main() {\n\tvar a interface{} = 2 + 5\n\tprintln(a.(int))\n}\n\n// Output:\n// 7\n"
},
{
"path": "_test/add1.go",
"chars": 480,
"preview": "package main\n\nfunc main() {\n\tb := 2 // int\n\n\tvar c int = 5 + b\n\tprintln(c)\n\n\tvar d int32 = 6 + int32(b)\n\tprintln(d)\n\n\tva"
},
{
"path": "_test/add2.go",
"chars": 118,
"preview": "package main\n\ntype iface interface{}\n\nfunc main() {\n\tb := 2\n\tvar a iface = 5 + b\n\tprintln(a.(int))\n}\n\n// Output:\n// 7\n"
},
{
"path": "_test/addr0.go",
"chars": 267,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n)\n\ntype extendedRequest struct {\n\thttp.Request\n\n\tData string\n}\n\nfunc main() {\n"
},
{
"path": "_test/addr1.go",
"chars": 221,
"preview": "package main\n\nimport \"fmt\"\n\ntype T struct {\n\tA int\n\tB int\n}\n\nfunc main() {\n\ta := &[]T{\n\t\t{1, 2},\n\t\t{3, 4},\n\t}\n\tfmt.Print"
},
{
"path": "_test/addr2.go",
"chars": 1038,
"preview": "package main\n\nimport (\n\t\"encoding/xml\"\n\t\"errors\"\n\t\"fmt\"\n)\n\ntype Email struct {\n\tWhere string `xml:\"where,attr\"`\n\tAddr s"
},
{
"path": "_test/addr3.go",
"chars": 212,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\nfunc main() {\n\tvar a interface{}\n\ta = 2\n\tfmt.Println(a)\n\n\tvar b *interface{}\n\tb = &a\n\tf"
},
{
"path": "_test/addr4.go",
"chars": 1540,
"preview": "package main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log\"\n)\n\nconst jsonData = `[\n \"foo\",\n \"bar\"\n]`\n\nconst jsonData2 = `[\n "
},
{
"path": "_test/addr5.go",
"chars": 1133,
"preview": "package main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"net/url\"\n)\n\nfunc main() {\n\tbody := []byte(`{\n\t\t\"BODY_1\": \"VALUE_1\",\n\t\t\""
},
{
"path": "_test/and.go",
"chars": 238,
"preview": "package main\n\nfunc main() {\n\ta, b := 1, 2\n\n\tif f1() && f2() {\n\t\tprintln(a, b)\n\t}\n}\n\nfunc f1() bool {\n\tprintln(\"f1\")\n\t//r"
},
{
"path": "_test/and0.go",
"chars": 198,
"preview": "package main\n\nfunc main() {\n\ta, b := 1, 2\n\n\tif f2() && f1() {\n\t\tprintln(a, b)\n\t}\n}\n\nfunc f1() bool {\n\tprintln(\"f1\")\n\tret"
},
{
"path": "_test/and1.go",
"chars": 185,
"preview": "package main\n\nfunc main() {\n\ta := f2() && f1()\n\tprintln(a)\n}\n\nfunc f1() bool {\n\tprintln(\"f1\")\n\treturn true\n}\n\nfunc f2() "
},
{
"path": "_test/and2.go",
"chars": 234,
"preview": "package main\n\nfunc f() bool {\n\tprintln(\"in f\")\n\treturn true\n}\n\nfunc main() {\n\tvar (\n\t\tcl = 0\n\t\tct = \"some text\"\n\t\tce = \""
},
{
"path": "_test/and3.go",
"chars": 84,
"preview": "package main\n\nvar a = true && true\n\nfunc main() {\n\tprintln(a)\n}\n\n// Output:\n// true\n"
},
{
"path": "_test/append0.go",
"chars": 183,
"preview": "package main\n\nimport \"fmt\"\n\nfunc f(a []int, b int) interface{} { return append(a, b) }\n\nfunc main() {\n\ta := []int{1, 2}\n"
},
{
"path": "_test/append1.go",
"chars": 224,
"preview": "package main\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n)\n\nfunc main() {\n\ts := bufio.NewScanner(bytes.NewReader([]byte(\"Hello\\nTest\\nLi"
},
{
"path": "_test/append2.go",
"chars": 216,
"preview": "package main\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n)\n\nfunc main() {\n\ts := bufio.NewScanner(bytes.NewReader([]byte(\"Hello\\nTest\\nLi"
},
{
"path": "_test/append3.go",
"chars": 192,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := []int{1, 2}\n\tb := [2]int{3, 4}\n\tfmt.Println(append(a, b[:]...))\n\tfmt.Pri"
},
{
"path": "_test/append4.go",
"chars": 118,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := []*int{}\n\ta = append(a, nil)\n\tfmt.Println(a)\n}\n\n// Output:\n// [<nil>]\n"
},
{
"path": "_test/assert0.go",
"chars": 2506,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\ntype MyWriter interface {\n\tWrite(p []byte) (i int, err error)\n}\n\ntype DummyWrit"
},
{
"path": "_test/assert1.go",
"chars": 1831,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"time\"\n)\n\ntype TestStruct struct{}\n\nfunc (t TestStruct) String() string {\n\tret"
},
{
"path": "_test/assert2.go",
"chars": 630,
"preview": "package main\n\nimport (\n\t\"strings\"\n\t\"sync\"\n)\n\n// Define an interface of stringBuilder that is compatible with\n// strings."
},
{
"path": "_test/assert3.go",
"chars": 198,
"preview": "package main\n\nimport \"crypto/rsa\"\n\nfunc main() {\n\tvar pKey interface{} = &rsa.PublicKey{}\n\n\tif _, ok := pKey.(*rsa.Publi"
},
{
"path": "_test/assert4.go",
"chars": 102,
"preview": "package main\n\nvar cc interface{} = 2\nvar dd = cc.(int)\n\nfunc main() {\n\tprintln(dd)\n}\n\n// Output:\n// 2\n"
},
{
"path": "_test/assign.go",
"chars": 97,
"preview": "package main\n\nfunc main() {\n\ta, b := 1, 2 // Multiple assign\n\tprintln(a, b)\n}\n\n// Output:\n// 1 2\n"
},
{
"path": "_test/assign0.go",
"chars": 286,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"time\"\n)\n\nfunc main() {\n\thttp.DefaultClient.Timeout = time.Second * 10\n\tfmt.P"
},
{
"path": "_test/assign1.go",
"chars": 108,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar buf []byte\n\n\tbuf = nil\n\tfmt.Println(buf)\n}\n\n// Output:\n// []\n"
},
{
"path": "_test/assign10.go",
"chars": 82,
"preview": "package main\n\nfunc main() {\n\tvar a uint\n\ta = 1 + 2\n\tprintln(a)\n}\n\n// Output:\n// 3\n"
},
{
"path": "_test/assign11.go",
"chars": 160,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\t_, _, _ = fmt.Println(\"test\")\n}\n\n// Error:\n// 6:2: assignment mismatch: 3 var"
},
{
"path": "_test/assign12.go",
"chars": 179,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta, b, c := fmt.Println(\"test\")\n\tprintln(a, b, c)\n}\n\n// Error:\n// 6:2: assignm"
},
{
"path": "_test/assign13.go",
"chars": 267,
"preview": "package main\n\nimport \"fmt\"\n\nfunc getStr() string {\n\treturn \"test\"\n}\n\nfunc main() {\n\tm := make(map[string]string, 0)\n\tm[\""
},
{
"path": "_test/assign14.go",
"chars": 191,
"preview": "package main\n\nvar optionsG map[string]string = nil\n\nvar roundG = 30\n\nfunc main() {\n\tdummy := roundG\n\troundG = dummy + 1\n"
},
{
"path": "_test/assign15.go",
"chars": 220,
"preview": "package main\n\nfunc main() {\n\tvar c chan<- struct{} = make(chan struct{})\n\tvar d <-chan struct{} = c\n\n\t_ = d\n}\n\n// Error:"
},
{
"path": "_test/assign16.go",
"chars": 135,
"preview": "package main\n\ntype H struct {\n\tbits uint\n}\n\nfunc main() {\n\th := &H{8}\n\tvar x uint = (1 << h.bits) >> 6\n\n\tprintln(x)\n}\n\n/"
},
{
"path": "_test/assign17.go",
"chars": 311,
"preview": "package main\n\nfunc main() {\n\ts := make([]map[string]string, 0)\n\tm := make(map[string]string)\n\tm[\"m1\"] = \"m1\"\n\tm[\"m2\"] = "
},
{
"path": "_test/assign18.go",
"chars": 301,
"preview": "package main\n\nfunc main() {\n\ts := make([]map[string]string, 0)\n\tm := make(map[string]string)\n\tm[\"m1\"] = \"m1\"\n\tm[\"m2\"] = "
},
{
"path": "_test/assign19.go",
"chars": 141,
"preview": "package main\n\nfunc main() {\n\ta, b, c := 1, 2\n\t_, _, _ = a, b, c\n}\n\n// Error:\n// _test/assign19.go:4:2: cannot assign 2 v"
},
{
"path": "_test/assign2.go",
"chars": 153,
"preview": "package main\n\nfunc main() {\n\tr := uint32(2000000000)\n\tr = hello(r)\n\tprintln(r)\n}\n\nfunc hello(r uint32) uint32 { return r"
},
{
"path": "_test/assign3.go",
"chars": 113,
"preview": "package main\n\nfunc main() {\n\ta, b := 1, 2\n\tprintln(a, b)\n\ta, b = b, a\n\tprintln(a, b)\n}\n\n// Output:\n// 1 2\n// 2 1\n"
},
{
"path": "_test/assign4.go",
"chars": 135,
"preview": "package main\n\nfunc main() {\n\ta, b, c := 1, 2, 3\n\tprintln(a, b, c)\n\ta, b, c = c, a, b\n\tprintln(a, b, c)\n}\n\n// Output:\n// "
},
{
"path": "_test/assign5.go",
"chars": 149,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tt := []int{1, 2}\n\tfmt.Println(t)\n\tt[0], t[1] = t[1], t[0]\n\tfmt.Println(t)\n}\n\n"
},
{
"path": "_test/assign6.go",
"chars": 198,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tt := map[string]int{\"a\": 1, \"b\": 2}\n\tfmt.Println(t[\"a\"], t[\"b\"])\n\tt[\"a\"], t[\""
},
{
"path": "_test/assign7.go",
"chars": 234,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := 3\n\tt := map[string]int{\"a\": 1, \"b\": 2}\n\ts := []int{4, 5}\n\tfmt.Println(a,"
},
{
"path": "_test/assign8.go",
"chars": 66,
"preview": "package main\n\nfunc main() {\n\t_ = 1\n\tprintln(1)\n}\n\n// Output:\n// 1\n"
},
{
"path": "_test/assign9.go",
"chars": 139,
"preview": "package main\n\ntype foo func(b int)\n\nfunc boo(b int) { println(\"boo\", b) }\n\nfunc main() {\n\tvar f foo\n\n\tf = boo\n\tf(4)\n}\n\n/"
},
{
"path": "_test/b1/foo/foo.go",
"chars": 117,
"preview": "package foo\n\nimport bar \"github.com/traefik/yaegi/_test/b2/foo\"\n\nvar Desc = \"in b1/foo\"\n\nvar Desc2 = Desc + bar.Desc\n"
},
{
"path": "_test/b2/foo/foo.go",
"chars": 36,
"preview": "package foo\n\nvar Desc = \"in b2/foo\"\n"
},
{
"path": "_test/bad0.go",
"chars": 70,
"preview": "println(\"Hello\")\n\n// Error:\n// 1:1: expected 'package', found println\n"
},
{
"path": "_test/baz-bat/baz-bat.go",
"chars": 34,
"preview": "package baz\n\nvar Name = \"baz-bat\"\n"
},
{
"path": "_test/bin.go",
"chars": 95,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tf := fmt.Println\n\tf(\"Hello\")\n}\n\n// Output:\n// Hello\n"
},
{
"path": "_test/bin0.go",
"chars": 127,
"preview": "package main\n\nimport \"strings\"\n\nfunc main() {\n\ta := strings.SplitN(\"truc machin\", \" \", 2)\n\tprintln(a[0])\n}\n\n// Output:\n/"
},
{
"path": "_test/bin1.go",
"chars": 230,
"preview": "package main\n\nimport (\n\t\"crypto/sha1\"\n\t\"fmt\"\n)\n\nfunc main() {\n\td := sha1.New()\n\td.Write([]byte(\"password\"))\n\ta := d.Sum("
},
{
"path": "_test/bin2.go",
"chars": 101,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"math\"\n)\n\nfunc main() {\n\tfmt.Println(math.Abs(-5))\n}\n\n// Output:\n// 5\n"
},
{
"path": "_test/bin3.go",
"chars": 139,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tstr := \"part1\"\n\tstr += fmt.Sprintf(\"%s\", \"part2\")\n\tfmt.Println(str)\n}\n\n// Out"
},
{
"path": "_test/bin4.go",
"chars": 313,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\nfunc Bar(s string) bool {\n\ta := strings.HasPrefix(\"fas\", \"f\")\n\tb := strings."
},
{
"path": "_test/bin5.go",
"chars": 192,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"net\"\n)\n\nfunc main() {\n\taddr := net.TCPAddr{IP: net.IPv4(1, 1, 1, 1), Port: 80}\n\tvar s fm"
},
{
"path": "_test/binstruct_ptr_map0.go",
"chars": 198,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"image\"\n)\n\nfunc main() {\n\tv := map[string]*image.Point{\n\t\t\"foo\": {X: 3, Y: 2},\n\t\t\"bar\": {"
},
{
"path": "_test/binstruct_ptr_slice0.go",
"chars": 160,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"image\"\n)\n\nfunc main() {\n\tv := []*image.Point{\n\t\t{X: 3, Y: 2},\n\t\t{X: 4, Y: 5},\n\t}\n\tfmt.Pr"
},
{
"path": "_test/binstruct_slice0.go",
"chars": 137,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"image\"\n)\n\nfunc main() {\n\tv := []image.Point{\n\t\t{X: 3, Y: 2},\n\t}\n\tfmt.Println(v)\n}\n\n// Ou"
},
{
"path": "_test/bltn.go",
"chars": 69,
"preview": "package main\n\nfunc main() {\n\tprintln(\"Hello\")\n}\n\n// Output:\n// Hello\n"
},
{
"path": "_test/bltn0.go",
"chars": 119,
"preview": "package main\n\nfunc main() {\n\tf := println\n\tf(\"Hello\")\n}\n\n// Error:\n// 4:7: use of builtin println not in function call\n"
},
{
"path": "_test/bool.go",
"chars": 96,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(false, true)\n}\n\n// Output:\n// false true\n"
},
{
"path": "_test/bool0.go",
"chars": 83,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(true)\n}\n\n// Output:\n// true\n"
},
{
"path": "_test/bool1.go",
"chars": 142,
"preview": "package main\n\ntype T struct {\n\tv bool\n}\n\nfunc main() {\n\ta := T{}\n\tif a.v {\n\t\tprintln(\"ok\")\n\t} else {\n\t\tprintln(\"nok\")\n\t}"
},
{
"path": "_test/bool2.go",
"chars": 143,
"preview": "package main\n\ntype T struct {\n\tv bool\n}\n\nfunc main() {\n\ta := &T{}\n\tif a.v {\n\t\tprintln(\"ok\")\n\t} else {\n\t\tprintln(\"nok\")\n\t"
},
{
"path": "_test/bool3.go",
"chars": 135,
"preview": "package main\n\nfunc main() {\n\tm := map[int]bool{0: false, 1: true}\n\tif m[0] {\n\t\tprintln(0)\n\t} else {\n\t\tprintln(1)\n\t}\n}\n\n/"
},
{
"path": "_test/bool4.go",
"chars": 123,
"preview": "package main\n\nfunc main() {\n\tm := []bool{false, true}\n\tif m[0] {\n\t\tprintln(0)\n\t} else {\n\t\tprintln(1)\n\t}\n}\n\n// Output:\n//"
},
{
"path": "_test/bool5.go",
"chars": 117,
"preview": "package main\n\nfunc main() {\n\tvar b bool\n\tm := &b\n\n\tif *m {\n\t\tprintln(0)\n\t} else {\n\t\tprintln(1)\n\t}\n}\n\n// Output:\n// 1\n"
},
{
"path": "_test/break0.go",
"chars": 320,
"preview": "package main\n\nfunc main() {\n\tn := 2\n\tm := 2\n\tfoo := true\nOuterLoop:\n\tprintln(\"Boo\")\n\tfor i := 0; i < n; i++ {\n\t\tprintln("
},
{
"path": "_test/break1.go",
"chars": 283,
"preview": "package main\n\nfunc main() {\n\tn := 2\n\tm := 2\n\tfoo := true\nOuterLoop:\n\tfor i := 0; i < n; i++ {\n\t\tprintln(\"I: \", i)\n\t\tfor "
},
{
"path": "_test/break2.go",
"chars": 306,
"preview": "package main\n\nfunc main() {\n\tn := 2\n\tm := 2\n\tfoo := true\nOuterLoop:\n\tfor i := 0; i < n; i++ {\n\t\tprintln(\"I: \", i)\n\t\tfor "
},
{
"path": "_test/break3.go",
"chars": 334,
"preview": "package main\n\nfunc main() {\n\tn := 2\n\tm := 2\n\tfoo := true\n\tgoto OuterLoop\n\tprintln(\"Boo\")\nOuterLoop:\n\tfor i := 0; i < n; "
},
{
"path": "_test/c1/c1.go",
"chars": 77,
"preview": "package c1\n\nimport \"github.com/traefik/yaegi/_test/c2\"\n\nvar C1 = c2.C2 + \"x\"\n"
},
{
"path": "_test/c2/c2.go",
"chars": 77,
"preview": "package c2\n\nimport \"github.com/traefik/yaegi/_test/c1\"\n\nvar C2 = c1.C1 + \"Y\"\n"
},
{
"path": "_test/cap0.go",
"chars": 194,
"preview": "package main\n\nfunc f(a []int) interface{} {\n\treturn cap(a)\n}\n\nfunc g(a []int) int {\n\treturn cap(a)\n}\n\nfunc main() {\n\ta :"
},
{
"path": "_test/chan0.go",
"chars": 190,
"preview": "package main\n\ntype Channel chan string\n\nfunc send(c Channel) { c <- \"ping\" }\n\nfunc main() {\n\tchannel := make(Channel)\n\tg"
},
{
"path": "_test/chan1.go",
"chars": 174,
"preview": "package main\n\nfunc send(c chan<- string) { c <- \"ping\" }\n\nfunc main() {\n\tchannel := make(chan string)\n\tgo send(channel)\n"
},
{
"path": "_test/chan10.go",
"chars": 155,
"preview": "package main\n\nimport \"time\"\n\nfunc main() {\n\tvar tick <-chan time.Time = time.Tick(time.Millisecond)\n\t_ = tick\n\tprintln(\""
},
{
"path": "_test/chan2.go",
"chars": 170,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tmessages := make(chan string)\n\n\tgo func() { messages <- \"ping\" }()\n\n\tmsg := <"
},
{
"path": "_test/chan3.go",
"chars": 168,
"preview": "package main\n\nfunc send(c chan<- int32) { c <- 123 }\n\nfunc main() {\n\tchannel := make(chan int32)\n\tgo send(channel)\n\tmsg "
},
{
"path": "_test/chan4.go",
"chars": 198,
"preview": "package main\n\nfunc send(c chan<- bool) { c <- false }\n\nfunc main() {\n\tchannel := make(chan bool)\n\tgo send(channel)\n\tif <"
},
{
"path": "_test/chan5.go",
"chars": 493,
"preview": "package main\n\nimport \"time\"\n\nfunc main() {\n\n\t// For our example we'll select across two channels.\n\tc1 := make(chan strin"
},
{
"path": "_test/chan6.go",
"chars": 157,
"preview": "package main\n\nfunc send(c chan<- int32) { c <- 123 }\n\nfunc main() {\n\tchannel := make(chan int32)\n\tgo send(channel)\n\tmsg,"
},
{
"path": "_test/chan7.go",
"chars": 197,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tqueue := make(chan string, 2)\n\tqueue <- \"one\"\n\tqueue <- \"two\"\n\tclose(queue)\n\t"
},
{
"path": "_test/chan8.go",
"chars": 144,
"preview": "package main\n\nfunc main() {\n\tmessages := make(chan bool)\n\n\tgo func() { messages <- true }()\n\n\tprintln(<-messages && true"
},
{
"path": "_test/chan9.go",
"chars": 234,
"preview": "package main\n\ntype Channel chan string\n\ntype T struct {\n\tChannel\n}\n\nfunc send(c Channel) { c <- \"ping\" }\n\nfunc main() {\n"
},
{
"path": "_test/cli1.go",
"chars": 835,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net\"\n\t\"net/http\"\n)\n\nfunc client(uri string) {\n\tresp, err := http.Get(uri)\n\t"
},
{
"path": "_test/cli2.go",
"chars": 943,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net\"\n\t\"net/http\"\n)\n\ntype T struct {\n\tln net.Listener\n}\n\nfunc (t *T) Close()"
},
{
"path": "_test/cli3.go",
"chars": 547,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n)\n\nfunc client(uri string) {\n\tresp, err := h"
},
{
"path": "_test/cli4.go",
"chars": 765,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n)\n\ntype mw1 struct {\n\tnext http.Handler\n}\n\nf"
},
{
"path": "_test/cli5.go",
"chars": 771,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n)\n\ntype mw1 struct {\n\tnext http.Handler\n}\n\nf"
},
{
"path": "_test/cli6.go",
"chars": 736,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n)\n\ntype T struct {\n\thttp.ResponseWriter\n}\n\nt"
},
{
"path": "_test/cli7.go",
"chars": 800,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"log\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n)\n\ntype T struct {\n\thttp.ResponseWriter\n}\n\nt"
},
{
"path": "_test/cli8.go",
"chars": 738,
"preview": "package main\n\nimport (\n\t\"net/http\"\n\t\"net/http/httptest\"\n)\n\ntype T struct {\n\tname string\n\tnext http.Handler\n}\n\nfunc (t *T"
},
{
"path": "_test/closure0.go",
"chars": 194,
"preview": "package main\n\ntype adder func(int, int) int\n\nfunc genAdd(k int) adder {\n\treturn func(i, j int) int {\n\t\treturn i + j + k\n"
},
{
"path": "_test/closure1.go",
"chars": 234,
"preview": "package main\n\ntype adder func(int, int) int\n\nfunc genAdd(k int) adder {\n\treturn func(i, j int) int {\n\t\treturn i + j + k\n"
},
{
"path": "_test/closure10.go",
"chars": 218,
"preview": "package main\n\nfunc main() {\n\tfoos := []func(){}\n\n\tfor i := 0; i < 3; i++ {\n\t\ta, b := i, i\n\t\tfoos = append(foos, func() {"
},
{
"path": "_test/closure11.go",
"chars": 236,
"preview": "package main\n\ntype T struct {\n\tF func()\n}\n\nfunc main() {\n\tfoos := []T{}\n\n\tfor i := 0; i < 3; i++ {\n\t\ta := i\n\t\tfoos = app"
},
{
"path": "_test/closure12.go",
"chars": 295,
"preview": "package main\n\nimport \"fmt\"\n\ntype T struct {\n\tF func()\n}\n\nfunc main() {\n\tfoos := []T{}\n\n\tfor i := 0; i < 3; i++ {\n\t\ta := "
},
{
"path": "_test/closure13.go",
"chars": 478,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n)\n\ntype monkey struct {\n\ttest func() int\n}\n\nfunc main() {\n\tinput := []string{\"1"
},
{
"path": "_test/closure14.go",
"chars": 462,
"preview": "package main\n\nimport \"fmt\"\n\ntype monkey struct {\n\ttest func() int\n}\n\nfunc getk(k int) (int, error) { return k, nil }\n\nfu"
},
{
"path": "_test/closure15.go",
"chars": 197,
"preview": "package main\n\nfunc main() {\n\tfoos := []func(){}\n\n\tfor i := range 3 {\n\t\ta := i\n\t\tfoos = append(foos, func() { println(i, "
},
{
"path": "_test/closure16.go",
"chars": 212,
"preview": "package main\n\nfunc main() {\n\tfoos := []func(){}\n\n\tfor i := range 3 {\n\t\ta, b := i, i\n\t\tfoos = append(foos, func() { print"
},
{
"path": "_test/closure17.go",
"chars": 230,
"preview": "package main\n\ntype T struct {\n\tF func()\n}\n\nfunc main() {\n\tfoos := []T{}\n\n\tfor i := range 3 {\n\t\ta := i\n\t\tfoos = append(fo"
},
{
"path": "_test/closure18.go",
"chars": 289,
"preview": "package main\n\nimport \"fmt\"\n\ntype T struct {\n\tF func()\n}\n\nfunc main() {\n\tfoos := []T{}\n\n\tfor i := range 3 {\n\t\ta := i\n\t\tn "
},
{
"path": "_test/closure19.go",
"chars": 194,
"preview": "package main\n\nfunc main() {\n\tfoos := []func(){}\n\n\tfor i := 0; i < 3; i++ {\n\t\ti := i\n\t\tfoos = append(foos, func() { print"
},
{
"path": "_test/closure2.go",
"chars": 323,
"preview": "package main\n\nfunc adder() func(int) int {\n\tsum := 0\n\treturn func(x int) int {\n\t\tsum = sum + x\n\t\treturn sum\n\t}\n}\n\nfunc m"
},
{
"path": "_test/closure20.go",
"chars": 188,
"preview": "package main\n\nfunc main() {\n\tfoos := []func(){}\n\n\tfor i := range 3 {\n\t\ti := i\n\t\tfoos = append(foos, func() { println(i) "
},
{
"path": "_test/closure3.go",
"chars": 250,
"preview": "package main\n\ntype T1 struct {\n\tName string\n}\n\nfunc (t *T1) genAdd(k int) func(int) int {\n\treturn func(i int) int {\n\t\tpr"
},
{
"path": "_test/closure4.go",
"chars": 249,
"preview": "package main\n\ntype T1 struct {\n\tName string\n}\n\nfunc (t *T1) genAdd(k int) func(int) int {\n\treturn func(i int) int {\n\t\tpr"
},
{
"path": "_test/closure5.go",
"chars": 248,
"preview": "package main\n\ntype T1 struct {\n\tName string\n}\n\nfunc (t T1) genAdd(k int) func(int) int {\n\treturn func(i int) int {\n\t\tpri"
},
{
"path": "_test/closure6.go",
"chars": 250,
"preview": "package main\n\ntype T1 struct {\n\tName string\n}\n\nfunc (t *T1) genAdd(k int) func(int) int {\n\treturn func(i int) int {\n\t\tpr"
},
{
"path": "_test/closure7.go",
"chars": 265,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\ntype Config struct {\n\tA string\n}\n\nvar conf *Config = &Config{}\n\nfunc SetConfig() func(*"
},
{
"path": "_test/closure8.go",
"chars": 104,
"preview": "package main\n\nvar f = func(a int) int { return 2 + a }\n\nfunc main() {\n\tprintln(f(3))\n}\n\n// Output:\n// 5\n"
},
{
"path": "_test/closure9.go",
"chars": 203,
"preview": "package main\n\nfunc main() {\n\tfoos := []func(){}\n\n\tfor i := 0; i < 3; i++ {\n\t\ta := i\n\t\tfoos = append(foos, func() { print"
},
{
"path": "_test/comp0.go",
"chars": 68,
"preview": "package main\n\nfunc main() {\n\tprintln(2 < 2.4)\n}\n\n// Output:\n// true\n"
},
{
"path": "_test/comp1.go",
"chars": 96,
"preview": "package main\n\nfunc main() {\n\tvar a interface{} = 1 < 2\n\tprintln(a.(bool))\n}\n\n// Output:\n// true\n"
},
{
"path": "_test/comp2.go",
"chars": 130,
"preview": "package main\n\ntype delta int32\n\nfunc main() {\n\ta := delta(-1)\n\n\tprintln(a != -1)\n\tprintln(a == -1)\n}\n\n// Output:\n// fals"
},
{
"path": "_test/complex0.go",
"chars": 124,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := complex(3, 2)\n\tfmt.Println(a, real(a), imag(a))\n}\n\n// Output:\n// (3+2i) "
},
{
"path": "_test/complex1.go",
"chars": 131,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar c complex128\n\tc = 1\n\tfmt.Printf(\"%T %v\\n\", c, c)\n}\n\n// Output:\n// complex"
},
{
"path": "_test/complex2.go",
"chars": 134,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tc := complex(1, 0)\n\tc += 1\n\tfmt.Printf(\"%T %v\\n\", c, c)\n}\n\n// Output:\n// comp"
},
{
"path": "_test/complex3.go",
"chars": 125,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar s int = 1 + complex(1, 0)\n\tfmt.Printf(\"%T %v\\n\", s, s)\n}\n\n// Output:\n// i"
},
{
"path": "_test/complex4.go",
"chars": 168,
"preview": "package main\n\nimport \"fmt\"\n\nfunc f(a, b float64) interface{} { return complex(a, b) }\n\nfunc main() {\n\ta := f(3, 2)\n\tfmt."
},
{
"path": "_test/composite0.go",
"chars": 126,
"preview": "package main\n\nimport \"fmt\"\n\nvar a = &[]*T{}\n\ntype T struct{ name string }\n\nfunc main() {\n\tfmt.Println(a)\n}\n\n// Output:\n/"
},
{
"path": "_test/composite1.go",
"chars": 134,
"preview": "package main\n\nimport \"fmt\"\n\nvar a = &[]*T{{}}\n\ntype T struct{ name string }\n\nfunc main() {\n\tfmt.Println((*a)[0])\n}\n\n// O"
},
{
"path": "_test/composite10.go",
"chars": 148,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ta := []map[int]int{make(map[int]int)}\n\n\tfor _, b := range a {\n\t\tfmt.Println(b"
},
{
"path": "_test/composite11.go",
"chars": 138,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"image/color\"\n)\n\nfunc main() {\n\tc := color.NRGBA64{1, 1, 1, 1}\n\n\tfmt.Println(c)\n}\n\n// Out"
},
{
"path": "_test/composite12.go",
"chars": 143,
"preview": "package main\n\ntype A struct {\n\tC D\n}\n\ntype D struct {\n\tE string\n}\n\nfunc main() {\n\ta := A{}\n\ta.C = D{\"bb\"}\n\n\tprintln(a.C."
},
{
"path": "_test/composite13.go",
"chars": 146,
"preview": "package main\n\ntype A struct {\n\tC D\n}\n\ntype D struct {\n\tE string\n}\n\nfunc main() {\n\ta := A{}\n\ta.C = D{E: \"bb\"}\n\n\tprintln(a"
},
{
"path": "_test/composite14.go",
"chars": 122,
"preview": "package main\n\nimport \"fmt\"\n\ntype T struct {\n\tb []byte\n}\n\nfunc main() {\n\tt := T{nil}\n\tfmt.Println(t)\n}\n\n// Output:\n// {[]"
},
{
"path": "_test/composite15.go",
"chars": 546,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\nfunc interfaceAsInts() {\n\tvar a interface{}\n\tb := 2\n\tc := 3\n\ta = []int{b, c}\n\n\td, ok :="
},
{
"path": "_test/composite16.go",
"chars": 159,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"net/url\"\n)\n\nfunc main() {\n\tbody := url.Values{\n\t\t\"Action\": {\"none\"},\n\t}\n\tfmt.Println(bod"
},
{
"path": "_test/composite17.go",
"chars": 379,
"preview": "package main\n\nimport (\n\t\"html/template\"\n)\n\nvar str = `{{ stringOr .Data \"test\" }}`\n\nfunc main() {\n\t_, err := template.Ne"
},
{
"path": "_test/composite18.go",
"chars": 372,
"preview": "package main\n\nimport \"fmt\"\n\ntype fn func(string, string) bool\n\nvar funcs = []fn{\n\tcmpLessFn,\n\tcmpGreaterFn,\n\tnil,\n}\n\nfun"
},
{
"path": "_test/composite19.go",
"chars": 461,
"preview": "package main\n\nimport \"fmt\"\n\ntype fn func(string, string) bool\n\nvar funcs = map[string]fn{\n\t\"less\": cmpLessFn,\n\t\"great"
},
{
"path": "_test/composite2.go",
"chars": 146,
"preview": "package main\n\nimport \"fmt\"\n\nvar a = &[]*T{{\"hello\"}}\n\ntype T struct{ name string }\n\nfunc main() {\n\tfmt.Println((*a)[0])\n"
},
{
"path": "_test/composite3.go",
"chars": 134,
"preview": "package main\n\nfunc main() {\n\tvar err error\n\tvar ok bool\n\n\t_, ok = err.(interface{ IsSet() bool })\n\tprintln(ok)\n}\n\n// Out"
},
{
"path": "_test/composite4.go",
"chars": 122,
"preview": "package main\n\nfunc main() {\n\tvar err error\n\n\t_, ok := err.(interface{ IsSet() bool })\n\tprintln(ok)\n}\n\n// Output:\n// fals"
},
{
"path": "_test/composite5.go",
"chars": 133,
"preview": "package main\n\nimport \"fmt\"\n\ntype T struct {\n\tm uint16\n}\n\nvar t = T{1<<2 | 1<<3}\n\nfunc main() {\n\tfmt.Println(t)\n}\n\n// Out"
},
{
"path": "_test/composite6.go",
"chars": 175,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/traefik/yaegi/_test/ct1\"\n)\n\ntype T struct {\n\tm uint16\n}\n\nvar t = T{1 << ct1."
},
{
"path": "_test/composite7.go",
"chars": 181,
"preview": "package main\n\ntype T struct {\n\tname string\n}\n\nvar tab = []*T{{\n\tname: \"foo\",\n}, {\n\tname: \"bar\",\n}}\n\nfunc main() {\n\tprint"
},
{
"path": "_test/composite8.go",
"chars": 187,
"preview": "package main\n\ntype T struct{ I int }\n\nfunc main() {\n\tt := []*T{}\n\ts := []int{1, 2}\n\tfor _, e := range s {\n\t\tx := &T{e}\n\t"
},
{
"path": "_test/composite8bis.go",
"chars": 190,
"preview": "package main\n\ntype T struct{ I int }\n\nfunc main() {\n\tt := []*T{}\n\ts := []int{1, 2}\n\tfor _, e := range s {\n\t\tx := &T{I: e"
}
]
// ... and 1454 more files (download for full content)
About this extraction
This page contains the full source code of the traefik/yaegi GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1654 files (18.4 MB), approximately 4.9M tokens, and a symbol index with 5736 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.