Diff of the two buildlogs: -- --- b1/build.log 2025-02-16 07:28:21.025695536 +0000 +++ b2/build.log 2025-02-16 11:09:08.028419129 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Fri Mar 20 22:59:23 -12 2026 -I: pbuilder-time-stamp: 1774090763 +I: Current time: Sun Feb 16 21:28:24 +14 2025 +I: pbuilder-time-stamp: 1739690904 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/unstable-reproducible-base.tgz] I: copying local configuration @@ -26,52 +26,84 @@ dpkg-source: info: applying update-packaged-javascript-links.patch I: Not using root during the build. I: Installing the build-deps -I: user script /srv/workspace/pbuilder/3553977/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/2461830/tmp/hooks/D01_modify_environment starting +debug: Running on ionos11-amd64. +I: Changing host+domainname to test build reproducibility +I: Adding a custom variable just for the fun of it... +I: Changing /bin/sh to bash +'/bin/sh' -> '/bin/bash' +lrwxrwxrwx 1 root root 9 Feb 16 07:28 /bin/sh -> /bin/bash +I: Setting pbuilder2's login shell to /bin/bash +I: Setting pbuilder2's GECOS to second user,second room,second work-phone,second home-phone,second other +I: user script /srv/workspace/pbuilder/2461830/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/2461830/tmp/hooks/D02_print_environment starting I: set - BUILDDIR='/build/reproducible-path' - BUILDUSERGECOS='first user,first room,first work-phone,first home-phone,first other' - BUILDUSERNAME='pbuilder1' - BUILD_ARCH='amd64' - DEBIAN_FRONTEND='noninteractive' - DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=42 ' - DISTRIBUTION='unstable' - HOME='/root' - HOST_ARCH='amd64' + BASH=/bin/sh + BASHOPTS=checkwinsize:cmdhist:complete_fullquote:extquote:force_fignore:globasciiranges:globskipdots:hostcomplete:interactive_comments:patsub_replacement:progcomp:promptvars:sourcepath + BASH_ALIASES=() + BASH_ARGC=() + BASH_ARGV=() + BASH_CMDS=() + BASH_LINENO=([0]="12" [1]="0") + BASH_LOADABLES_PATH=/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:. + BASH_SOURCE=([0]="/tmp/hooks/D02_print_environment" [1]="/tmp/hooks/D02_print_environment") + BASH_VERSINFO=([0]="5" [1]="2" [2]="37" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu") + BASH_VERSION='5.2.37(1)-release' + BUILDDIR=/build/reproducible-path + BUILDUSERGECOS='second user,second room,second work-phone,second home-phone,second other' + BUILDUSERNAME=pbuilder2 + BUILD_ARCH=amd64 + DEBIAN_FRONTEND=noninteractive + DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=20 ' + DIRSTACK=() + DISTRIBUTION=unstable + EUID=0 + FUNCNAME=([0]="Echo" [1]="main") + GROUPS=() + HOME=/root + HOSTNAME=i-capture-the-hostname + HOSTTYPE=x86_64 + HOST_ARCH=amd64 IFS=' ' - INVOCATION_ID='6bf631419cfc4fbd88102821c92ef5a1' - LANG='C' - LANGUAGE='en_US:en' - LC_ALL='C' - MAIL='/var/mail/root' - OPTIND='1' - PATH='/usr/sbin:/usr/bin:/sbin:/bin:/usr/games' - PBCURRENTCOMMANDLINEOPERATION='build' - PBUILDER_OPERATION='build' - PBUILDER_PKGDATADIR='/usr/share/pbuilder' - PBUILDER_PKGLIBDIR='/usr/lib/pbuilder' - PBUILDER_SYSCONFDIR='/etc' - PPID='3553977' - PS1='# ' - PS2='> ' + INVOCATION_ID=8630b33601374133a70c174dfd4e27fa + LANG=C + LANGUAGE=et_EE:et + LC_ALL=C + MACHTYPE=x86_64-pc-linux-gnu + MAIL=/var/mail/root + OPTERR=1 + OPTIND=1 + OSTYPE=linux-gnu + PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path + PBCURRENTCOMMANDLINEOPERATION=build + PBUILDER_OPERATION=build + PBUILDER_PKGDATADIR=/usr/share/pbuilder + PBUILDER_PKGLIBDIR=/usr/lib/pbuilder + PBUILDER_SYSCONFDIR=/etc + PIPESTATUS=([0]="0") + POSIXLY_CORRECT=y + PPID=2461830 PS4='+ ' - PWD='/' - SHELL='/bin/bash' - SHLVL='2' - SUDO_COMMAND='/usr/bin/timeout -k 18.1h 18h /usr/bin/ionice -c 3 /usr/bin/nice /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.Z15QMKHg/pbuilderrc_U6fU --distribution unstable --hookdir /etc/pbuilder/first-build-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.Z15QMKHg/b1 --logfile b1/build.log crystal_1.14.0+dfsg-1.dsc' - SUDO_GID='110' - SUDO_UID='105' - SUDO_USER='jenkins' - TERM='unknown' - TZ='/usr/share/zoneinfo/Etc/GMT+12' - USER='root' - _='/usr/bin/systemd-run' - http_proxy='http://213.165.73.152:3128' + PWD=/ + SHELL=/bin/bash + SHELLOPTS=braceexpand:errexit:hashall:interactive-comments:posix + SHLVL=3 + SUDO_COMMAND='/usr/bin/timeout -k 24.1h 24h /usr/bin/ionice -c 3 /usr/bin/nice -n 11 /usr/bin/unshare --uts -- /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.Z15QMKHg/pbuilderrc_O8EH --distribution unstable --hookdir /etc/pbuilder/rebuild-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.Z15QMKHg/b2 --logfile b2/build.log crystal_1.14.0+dfsg-1.dsc' + SUDO_GID=111 + SUDO_UID=106 + SUDO_USER=jenkins + TERM=unknown + TZ=/usr/share/zoneinfo/Etc/GMT-14 + UID=0 + USER=root + _='I: set' + http_proxy=http://46.16.76.132:3128 I: uname -a - Linux ionos5-amd64 6.12.9+bpo-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.12.9-1~bpo12+1 (2025-01-19) x86_64 GNU/Linux + Linux i-capture-the-hostname 6.1.0-31-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.128-1 (2025-02-07) x86_64 GNU/Linux I: ls -l /bin - lrwxrwxrwx 1 root root 7 Nov 22 2024 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/3553977/tmp/hooks/D02_print_environment finished + lrwxrwxrwx 1 root root 7 Nov 22 14:40 /bin -> usr/bin +I: user script /srv/workspace/pbuilder/2461830/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -256,7 +288,7 @@ Get: 115 http://deb.debian.org/debian unstable/main amd64 llvm-19-tools amd64 1:19.1.7-1+b1 [511 kB] Get: 116 http://deb.debian.org/debian unstable/main amd64 llvm-19-dev amd64 1:19.1.7-1+b1 [43.2 MB] Get: 117 http://deb.debian.org/debian unstable/main amd64 zlib1g-dev amd64 1:1.3.dfsg+really1.3.1-1+b1 [920 kB] -Fetched 181 MB in 26s (6897 kB/s) +Fetched 181 MB in 14s (12.5 MB/s) Preconfiguring packages ... Selecting previously unselected package libpython3.13-minimal:amd64. (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 19808 files and directories currently installed.) @@ -645,8 +677,8 @@ Setting up tzdata (2025a-2) ... Current default time zone: 'Etc/UTC' -Local time is now: Sat Mar 21 11:01:33 UTC 2026. -Universal Time is now: Sat Mar 21 11:01:33 UTC 2026. +Local time is now: Sun Feb 16 07:32:41 UTC 2025. +Universal Time is now: Sun Feb 16 07:32:41 UTC 2025. Run 'dpkg-reconfigure tzdata' if you wish to change it. Setting up liberror-perl (0.17029-2) ... @@ -751,7 +783,11 @@ Building tag database... -> Finished parsing the build-deps I: Building the package -I: Running cd /build/reproducible-path/crystal-1.14.0+dfsg/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-genchanges -S > ../crystal_1.14.0+dfsg-1_source.changes +I: user script /srv/workspace/pbuilder/2461830/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for unstable +I: user script /srv/workspace/pbuilder/2461830/tmp/hooks/A99_set_merged_usr finished +hostname: Name or service not known +I: Running cd /build/reproducible-path/crystal-1.14.0+dfsg/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-genchanges -S > ../crystal_1.14.0+dfsg-1_source.changes dpkg-buildpackage: info: source package crystal dpkg-buildpackage: info: source version 1.14.0+dfsg-1 dpkg-buildpackage: info: source distribution unstable @@ -761,7 +797,7 @@ debian/rules clean dh clean dh_auto_clean - make -j42 clean + make -j20 clean make[1]: Entering directory '/build/reproducible-path/crystal-1.14.0+dfsg' rm -rf .build rm -rf ./docs @@ -780,19 +816,19 @@ dh_auto_configure debian/rules override_dh_auto_build make[1]: Entering directory '/build/reproducible-path/crystal-1.14.0+dfsg' -dh_auto_build -- release=1 verbose=1 progress=1 threads=42 CRYSTAL_CONFIG_PATH="lib:/usr/lib/crystal/lib" CRYSTAL_CACHE_DIR="/tmp/crystal" interpreter=1 - make -j42 "INSTALL=install --strip-program=true" release=1 verbose=1 progress=1 threads=42 CRYSTAL_CONFIG_PATH=lib:/usr/lib/crystal/lib CRYSTAL_CACHE_DIR=/tmp/crystal interpreter=1 +dh_auto_build -- release=1 verbose=1 progress=1 threads=20 CRYSTAL_CONFIG_PATH="lib:/usr/lib/crystal/lib" CRYSTAL_CACHE_DIR="/tmp/crystal" interpreter=1 + make -j20 "INSTALL=install --strip-program=true" release=1 verbose=1 progress=1 threads=20 CRYSTAL_CONFIG_PATH=lib:/usr/lib/crystal/lib CRYSTAL_CACHE_DIR=/tmp/crystal interpreter=1 make[2]: Entering directory '/build/reproducible-path/crystal-1.14.0+dfsg' Using /usr/bin/llvm-config-19 [version=19.1.7] -CRYSTAL_CONFIG_BUILD_COMMIT="" CRYSTAL_CONFIG_PATH=lib:/usr/lib/crystal/lib SOURCE_DATE_EPOCH="1734712509" CRYSTAL_CONFIG_LIBRARY_PATH='$ORIGIN/../lib/crystal' ./bin/crystal build -D strict_multi_assign -D preview_overload_order --release --progress --threads 42 --link-flags="-Wl,-z,relro" -o .build/crystal src/compiler/crystal.cr -D without_openssl -D without_zlib -D use_pcre2 +CRYSTAL_CONFIG_BUILD_COMMIT="" CRYSTAL_CONFIG_PATH=lib:/usr/lib/crystal/lib SOURCE_DATE_EPOCH="1734712509" CRYSTAL_CONFIG_LIBRARY_PATH='$ORIGIN/../lib/crystal' ./bin/crystal build -D strict_multi_assign -D preview_overload_order --release --progress --threads 20 --link-flags="-Wl,-z,relro" -o .build/crystal src/compiler/crystal.cr -D without_openssl -D without_zlib -D use_pcre2 [1/13] Parse [1/13] Parse [2/13] Semantic (top level) [2/13] Semantic (top level) [3/13] Semantic (new) [3/13] Semantic (new) [4/13] Semantic (type declarations) [4/13] Semantic (type declarations) [5/13] Semantic (abstract def check) [5/13] Semantic (abstract def check) [6/13] Semantic (restrictions augmenter) [6/13] Semantic (restrictions augmenter) [7/13] Semantic (ivars initializers) [7/13] Semantic (ivars initializers) [8/13] Semantic (cvars initializers) [8/13] Semantic (cvars initializers) [9/13] Semantic (main) [9/13] Semantic (main) [10/13] Semantic (cleanup) [10/13] Semantic (cleanup) [11/13] Semantic (recursive struct check) [11/13] Semantic (recursive struct check) [12/13] Codegen (crystal) [12/13] Codegen (crystal) [13/13] Codegen (bc+obj) [13/13] [0/1] Codegen (bc+obj) [13/13] [1/1] Codegen (bc+obj) [13/13] [1/1] Codegen (bc+obj) [14/13] Codegen (linking) [14/13] Codegen (linking) make[2]: Leaving directory '/build/reproducible-path/crystal-1.14.0+dfsg' make[1]: Leaving directory '/build/reproducible-path/crystal-1.14.0+dfsg' debian/rules override_dh_auto_test make[1]: Entering directory '/build/reproducible-path/crystal-1.14.0+dfsg' -make release=1 verbose=1 progress=1 threads=42 CRYSTAL_CONFIG_PATH="lib:/usr/lib/crystal/lib" CRYSTAL_CACHE_DIR="/tmp/crystal" interpreter=1 compiler_spec +make release=1 verbose=1 progress=1 threads=20 CRYSTAL_CONFIG_PATH="lib:/usr/lib/crystal/lib" CRYSTAL_CACHE_DIR="/tmp/crystal" interpreter=1 compiler_spec make[2]: Entering directory '/build/reproducible-path/crystal-1.14.0+dfsg' Using /usr/bin/llvm-config-19 [version=19.1.7] -CRYSTAL_CONFIG_BUILD_COMMIT="" CRYSTAL_CONFIG_PATH=lib:/usr/lib/crystal/lib SOURCE_DATE_EPOCH="1734712509" ./bin/crystal build -D strict_multi_assign -D preview_overload_order --release --progress --threads 42 --link-flags="-Wl,-z,relro" --exclude-warnings spec/std --exclude-warnings spec/compiler --exclude-warnings spec/primitives -o .build/compiler_spec spec/compiler_spec.cr --release +CRYSTAL_CONFIG_BUILD_COMMIT="" CRYSTAL_CONFIG_PATH=lib:/usr/lib/crystal/lib SOURCE_DATE_EPOCH="1734712509" ./bin/crystal build -D strict_multi_assign -D preview_overload_order --release --progress --threads 20 --link-flags="-Wl,-z,relro" --exclude-warnings spec/std --exclude-warnings spec/compiler --exclude-warnings spec/primitives -o .build/compiler_spec spec/compiler_spec.cr --release Using compiled compiler at .build/crystal In lib/markd/src/markd/renderers/html_renderer.cr:238:7 @@ -801,7 +837,7 @@ Warning: expanding macro -There was a problem expanding macro 'macro_140549799628400' +There was a problem expanding macro 'macro_140300317817808' Called macro defined in lib/markd/src/markd/renderers/html_renderer.cr:238:7 @@ -817,15232 +853,13243 @@ A total of 1 warnings were found. [1/13] Parse [1/13] Parse [2/13] Semantic (top level) [2/13] Semantic (top level) [3/13] Semantic (new) [3/13] Semantic (new) [4/13] Semantic (type declarations) [4/13] Semantic (type declarations) [5/13] Semantic (abstract def check) [5/13] Semantic (abstract def check) [6/13] Semantic (restrictions augmenter) [6/13] Semantic (restrictions augmenter) [7/13] Semantic (ivars initializers) [7/13] Semantic (ivars initializers) [8/13] Semantic (cvars initializers) [8/13] Semantic (cvars initializers) [9/13] Semantic (main) [9/13] Semantic (main) [10/13] Semantic (cleanup) [10/13] Semantic (cleanup) [11/13] Semantic (recursive struct check) [11/13] Semantic (recursive struct check) [12/13] Codegen (crystal) [12/13] Codegen (crystal) [13/13] Codegen (bc+obj) [13/13] [0/1] Codegen (bc+obj) [13/13] [1/1] Codegen (bc+obj) [13/13] [1/1] Codegen (bc+obj) [14/13] Codegen (linking) [14/13] Codegen (linking) .build/compiler_spec -v --order=random -Randomized with seed: 68465 -Crystal::Repl::Interpreter - casts - upcasts between named tuple types, different order upcasts between named tuple types, different order - upcasts between named tuple types, respects alignment (#14036) upcasts between named tuple types, respects alignment (#14036) - casts from nilable type to mixed union type (2) casts from nilable type to mixed union type (2) - discards cast discards cast - does as? with a type that can't match (#12346) does as? with a type that can't match (#12346) - casts from mixed union type to another mixed union type for caller casts from mixed union type to another mixed union type for caller - casts from mixed union type to primitive type casts from mixed union type to primitive type - upcasts to module type upcasts to module type - casts from reference to nilable reference casts from reference to nilable reference - raises when as fails raises when as fails - upcasts in nilable cast (#12532) upcasts in nilable cast (#12532) - upcasts GenericClassInstanceMetaclassType to VirtualMetaclassType upcasts GenericClassInstanceMetaclassType to VirtualMetaclassType - casts nilable from mixed union type to primitive type (nil case) casts nilable from mixed union type to primitive type (nil case) - does is_a? with virtual metaclass does is_a? with virtual metaclass - casts to filtered type, not type in as(...) casts to filtered type, not type in as(...) - upcasts virtual type to union upcasts virtual type to union - casts from mixed union type to nilable proc type (#12283) casts from mixed union type to nilable proc type (#12283) - casts nilable from mixed union type to primitive type (non-nil case) casts nilable from mixed union type to primitive type (non-nil case) - puts named tuple type inside union of different named tuple type (#12243) puts named tuple type inside union of different named tuple type (#12243) - does as? with no resulting type (#12327) does as? with no resulting type (#12327) - upcasts mixed union with tuple to mixed union with compatible tuple (3) (#12331) upcasts mixed union with tuple to mixed union with compatible tuple (3) (#12331) - casts from nilable type to mixed union type casts from nilable type to mixed union type - puts tuple type inside union of different tuple type (#12243) puts tuple type inside union of different tuple type (#12243) - upcasts between tuple types, respects alignment (#14036) upcasts between tuple types, respects alignment (#14036) - upcasts between tuple types upcasts between tuple types - casts nil to Void* casts nil to Void* - casts from reference to pointer and back casts from reference to pointer and back - upcasts mixed union with tuple to mixed union with compatible tuple (2) (#12331) upcasts mixed union with tuple to mixed union with compatible tuple (2) (#12331) - upcasts between named tuple types, same order upcasts between named tuple types, same order - puts virtual metaclass into union (#12162) puts virtual metaclass into union (#12162) - does as? with no resulting type, not from nil (#12327) does as? with no resulting type, not from nil (#12327) - does is_a? with virtual type (struct) does is_a? with virtual type (struct) - upcasts mixed union with tuple to mixed union with compatible tuple (1) (#12331) upcasts mixed union with tuple to mixed union with compatible tuple (1) (#12331) -Crystal::Repl::Interpreter - blocks - interprets block with args that conflict with a local var interprets block with args that conflict with a local var - interprets simplest block interprets simplest block - interprets yield with splat, less block arguments interprets yield with splat, less block arguments - interprets yield with splat, block with splat interprets yield with splat, block with splat - interprets block with args that conflict with a local var interprets block with args that conflict with a local var - clears block local variables when calling block clears block local variables when calling block - interprets break inside block (union, through break) interprets break inside block (union, through break) - interprets break inside block (union, through normal flow) interprets break inside block (union, through normal flow) - interprets yield inside def with arguments interprets yield inside def with arguments - interprets next inside block interprets next inside block - considers block arg without type as having NoReturn type (2) (#12270) considers block arg without type as having NoReturn type (2) (#12270) - discards yield expression discards yield expression - interprets break inside block (union, through return) interprets break inside block (union, through return) - interprets next inside block (union, through normal exit) interprets next inside block (union, through normal exit) - interprets yield with splat (2) interprets yield with splat (2) - interprets yield with splat (1) interprets yield with splat (1) - interprets yield inside another block interprets yield inside another block - clears block local variables when calling block (2) clears block local variables when calling block (2) - returns from block returns from block - interprets break inside block interprets break inside block - interprets next inside block (union, through next) interprets next inside block (union, through next) - interprets yield expressions interprets yield expressions - yields different values to form a union yields different values to form a union - interprets block with splat interprets block with splat - interprets yield expression interprets yield expression - interprets block with multiple yields interprets block with multiple yields - considers block arg without type as having NoReturn type (#12270) considers block arg without type as having NoReturn type (#12270) - caches method with captured block (#12276) caches method with captured block (#12276) - counts with ... yield scope in block args bytesize (#12316) counts with ... yield scope in block args bytesize (#12316) - casts yield expression to block var type (not block arg type) casts yield expression to block var type (not block arg type) - interprets with ... yield with extra arguments (#12296) interprets with ... yield with extra arguments (#12296) - interprets with ... yield with struct interprets with ... yield with struct - interprets with ... yield interprets with ... yield - interprets yield with splat, block with splat (#12227) interprets yield with splat, block with splat (#12227) - interprets yield return value interprets yield return value - captures non-closure block captures non-closure block -Semantic: alias - errors if declares alias inside if errors if declares alias inside if - overloads union type through alias overloads union type through alias - declares alias inside type declares alias inside type - includes module through alias includes module through alias - doesn't find type parameter in alias (#3502) doesn't find type parameter in alias (#3502) - uses constant in alias with math (#3259) uses constant in alias with math (#3259) - reopens module through alias reopens module through alias - resolves alias type resolves alias type - works with alias type as restriction works with alias type as restriction - doesn't crash by infinite recursion against type alias and generics (#5329) doesn't crash by infinite recursion against type alias and generics (#5329) - reopens class through alias within itself reopens class through alias within itself - inherits struct through alias inherits struct through alias - errors if alias already defined errors if alias already defined - allows using generic type of recursive alias as restriction (#488) allows using generic type of recursive alias as restriction (#488) - finds type through alias (#4645) finds type through alias (#4645) - inherits class through alias inherits class through alias - can pass recursive alias to proc can pass recursive alias to proc - errors if alias is already defined as another type errors if alias is already defined as another type - errors if defining infinite recursive alias in union errors if defining infinite recursive alias in union - resolves type through alias (#563) resolves type through alias (#563) - reopens struct through alias reopens struct through alias - errors if trying to use typeof in alias errors if trying to use typeof in alias - reopens struct through alias within itself reopens struct through alias within itself - errors if defining infinite recursive alias errors if defining infinite recursive alias - looks up alias for macro resolution (#3548) looks up alias for macro resolution (#3548) - allows recursive array with alias allows recursive array with alias - errors if trying to resolve type of recursive alias errors if trying to resolve type of recursive alias - can use .class in alias (#2835) can use .class in alias (#2835) - reopens module through alias within itself reopens module through alias within itself - allows defining recursive aliases allows defining recursive aliases - allows using alias type as generic type allows using alias type as generic type - uses constant in alias (#3259) uses constant in alias (#3259) - allows defining recursive fun aliases allows defining recursive fun aliases - reopens class through alias reopens class through alias -Semantic: yield with scope - passes #229 passes #229 - mentions with yield scope and current scope in error mentions with yield scope and current scope in error - errors if using instance variable at top level errors if using instance variable at top level - uses instance variable of enclosing scope uses instance variable of enclosing scope - infer type of empty block body infer type of empty block body - uses method of enclosing scope uses method of enclosing scope - infer type of block body infer type of block body - finds macro finds macro - infer type of block body with yield scope and arguments infer type of block body with yield scope and arguments - infer type of block body with yield scope infer type of block body with yield scope - invokes nested calls invokes nested calls -Code gen: void - codegens no return assignment codegens no return assignment - codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable - returns void from nil functions, doesn't crash when passing value returns void from nil functions, doesn't crash when passing value - codegens unreachable code codegens unreachable code - codegens void assignment codegens void assignment - codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case - allows passing void as argument to method allows passing void as argument to method +Randomized with seed: 76473 +Code gen: C ABI x86_64 + passes struct less than 64 bits as { i64 } passes struct less than 64 bits as { i64 } + passes struct between 64 and 128 bits as { i64, i64 } passes struct between 64 and 128 bits as { i64, i64 } + passes struct between 64 and 128 bits as { i64, i64 } (with multiple modules/contexts) passes struct between 64 and 128 bits as { i64, i64 } (with multiple modules/contexts) + returns struct less than 64 bits as { i64 } returns struct less than 64 bits as { i64 } + passes struct less than 64 bits as { i64 } in varargs passes struct less than 64 bits as { i64 } in varargs + passes struct bigger than128 bits with byval passes struct bigger than128 bits with byval + returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret + returns struct between 64 and 128 bits as { i64, i64 } returns struct between 64 and 128 bits as { i64, i64 } +Codegen: class var + initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal + doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module + declares var as uninitialized and initializes it unsafely declares var as uninitialized and initializes it unsafely + accesses class var from proc literal accesses class var from proc literal + codegens class var inside module codegens class var inside module + reads class var before initializing it (hoisting) reads class var before initializing it (hoisting) + reads class var from virtual type metaclass reads class var from virtual type metaclass + codegens class var with begin and vars codegens class var with begin and vars + doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) + codegens class var inside instance method codegens class var inside instance method + codegens generic class with class var codegens generic class with class var + inline initialization of simple class var inline initialization of simple class var + codegens second class var initializer codegens second class var initializer + initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it + declares and initializes declares and initializes + catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer + initializes class var of union with single type initializes class var of union with single type + doesn't inherit class var value in subclass doesn't inherit class var value in subclass + codegens class var with nilable reference type codegens class var with nilable reference type + writes class var from virtual type writes class var from virtual type + codegens class var codegens class var + codegens class var with type declaration begin and vars codegens class var with type declaration begin and vars + runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) + codegens class var as nil codegens class var as nil + initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var + doesn't use nilable type for initializer doesn't use nilable type for initializer + gets pointerof class var complex constant gets pointerof class var complex constant + codegens class var as nil if assigned for the first time inside method codegens class var as nil if assigned for the first time inside method + gets pointerof class var gets pointerof class var + uses var in class var initializer uses var in class var initializer + doesn't inherit class var value in module doesn't inherit class var value in module + reads simple class var before another complex one reads simple class var before another complex one + reads class var from virtual type reads class var from virtual type +Semantic: method_missing + doesn't look up method_missing in with_yield_scope if call has a receiver (#12097) doesn't look up method_missing in with_yield_scope if call has a receiver (#12097) + finds method_missing with 'with ... yield' finds method_missing with 'with ... yield' + errors if method_missing expands to multiple methods errors if method_missing expands to multiple methods + does method missing for generic type does method missing for generic type + errors if method_missing expands to an incorrect method errors if method_missing expands to an incorrect method + does error in method_missing macro with virtual type does error in method_missing macro with virtual type + does error in method_missing if wrong number of params does error in method_missing if wrong number of params +Code gen: alias + invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) + invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) + codegens cast to alias that includes bool codegens cast to alias that includes bool + overloads alias against generic (1) (#3261) overloads alias against generic (1) (#3261) + doesn't crash on cast to as recursive alias (#639) doesn't crash on cast to as recursive alias (#639) + casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias + invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) + casts to recursive alias casts to recursive alias + doesn't break with alias for link attributes doesn't break with alias for link attributes + lazily solves aliases (#1346) lazily solves aliases (#1346) + overloads alias against generic (2) (#3261) overloads alias against generic (2) (#3261) +Semantic: fun + errors if defining class inside fun through macro (#6874) errors if defining class inside fun through macro (#6874) +Code gen: var + codegens bug with var, while, if, break and ssa codegens bug with var, while, if, break and ssa + works with typeof with assignment (#828) works with typeof with assignment (#828) + codegens assignment that can never be reached codegens assignment that can never be reached + codegens ivar assignment when not-nil type filter applies codegens ivar assignment when not-nil type filter applies + codegens bug with union of int, nil and string (1): assigning nil to union must fill all zeros codegens bug with union of int, nil and string (1): assigning nil to union must fill all zeros + codegens bug with union of int, nil and string (2): assigning nil to union must fill all zeros codegens bug with union of int, nil and string (2): assigning nil to union must fill all zeros + codegens bug with instance vars and ssa codegens bug with instance vars and ssa + codegens var codegens var + codegens var with type declaration codegens var with type declaration + assigns to underscore assigns to underscore +Semantic: require + file not found + require require + relative wildcard relative wildcard + wildcard wildcard + relative require relative require +Code gen: ssa + codegens a var that is declared in a block (1) codegens a var that is declared in a block (1) + codegens ssa bug with if/else on var codegens ssa bug with if/else on var + codegens a redefined var codegens a redefined var + codegens declaration of var inside then when false codegens declaration of var inside then when false + codegens declaration of var inside then when true codegens declaration of var inside then when true + codegens a var that is re-assigned in a block (1) codegens a var that is re-assigned in a block (1) + codegens ssa bug (2) codegens ssa bug (2) + codegens ssa bug (1) codegens ssa bug (1) + codegens a var that is declared in a block (2) codegens a var that is declared in a block (2) + codegens a redefined var inside method with argument codegens a redefined var inside method with argument + codegens a redefined var inside method codegens a redefined var inside method + codegens a var that is re-assigned in a block (2) codegens a var that is re-assigned in a block (2) + codegens a var that is re-assigned in a block codegens a var that is re-assigned in a block Normalize: block - normalizes nested unpacking normalizes nested unpacking + normalizes unpacking with underscore normalizes unpacking with underscore normalizes unpacking with splat normalizes unpacking with splat normalizes unpacking with multiple body expressions normalizes unpacking with multiple body expressions - normalizes multiple nested unpackings normalizes multiple nested unpackings normalizes unpacking with single expression body normalizes unpacking with single expression body + normalizes multiple nested unpackings normalizes multiple nested unpackings normalizes unpacking with empty body normalizes unpacking with empty body - normalizes unpacking with underscore normalizes unpacking with underscore + normalizes nested unpacking normalizes nested unpacking +Semantic: private + finds private macro in same file finds private macro in same file + doesn't find private alias in another file doesn't find private alias in another file + can use types in private type can use types in private type + gives private constant error in macro gives private constant error in macro + doesn't find private macro in another file doesn't find private macro in another file + doesn't find private enum from outside namespace, long name (#8831) doesn't find private enum from outside namespace, long name (#8831) + doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) + doesn't find private def defined in macro in another file (#7681) doesn't find private def defined in macro in another file (#7681) + doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) + finds private def in same file finds private def in same file + finds private type in same file finds private type in same file + doesn't find private class defined through macro (#8715) doesn't find private class defined through macro (#8715) + doesn't find private class from outside namespace, long name (#8831) doesn't find private class from outside namespace, long name (#8831) + doesn't inherit visibility from class node in macro hook (#8794) doesn't inherit visibility from class node in macro hook (#8794) + find module private macro inside a module, which is inherited by the module find module private macro inside a module, which is inherited by the module + find module private macro inside the module find module private macro inside the module + doesn't find private class from outside namespace doesn't find private class from outside namespace + doesn't find private constant in another file (#7850) doesn't find private constant in another file (#7850) + doesn't define private constant with global type name doesn't define private constant with global type name + doesn't find private alias from outside namespace, long name (#8831) doesn't find private alias from outside namespace, long name (#8831) + doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) + doesn't find module private macro outside the module doesn't find module private macro outside the module + doesn't define private class with global type name doesn't define private class with global type name + doesn't find private enum from outside namespace doesn't find private enum from outside namespace + doesn't find private macro defined through macro (#8715) doesn't find private macro defined through macro (#8715) + doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) + doesn't define private alias with global type name doesn't define private alias with global type name + types private def correctly types private def correctly + doesn't define private module with global type name doesn't define private module with global type name + doesn't find private module from outside namespace, long name (#8831) doesn't find private module from outside namespace, long name (#8831) + can use instance var initializer in private type can use instance var initializer in private type + doesn't define private lib with global type name doesn't define private lib with global type name + finds private type from inside namespace in subclass finds private type from inside namespace in subclass + doesn't find private thing defined through recursive macro (#8715) doesn't find private thing defined through recursive macro (#8715) + finds private class in macro expansion finds private class in macro expansion + doesn't find private lib from outside namespace doesn't find private lib from outside namespace + doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) + finds private macro in same file, invoking from another macro (#1265) finds private macro in same file, invoking from another macro (#1265) + finds private def when invoking from inside macro (#2082) finds private def when invoking from inside macro (#2082) + doesn't find private def in another file doesn't find private def in another file + finds private type from inside namespace finds private type from inside namespace + finds private def in same file that invokes another def finds private def in same file that invokes another def + doesn't find private module from outside namespace doesn't find private module from outside namespace + doesn't find private class in another file doesn't find private class in another file + doesn't find private constant from outside namespace, long name (#8831) doesn't find private constant from outside namespace, long name (#8831) + doesn't find private alias from outside namespace doesn't find private alias from outside namespace + doesn't define private enum with global type name doesn't define private enum with global type name + doesn't find private lib from outside namespace, long name (#8831) doesn't find private lib from outside namespace, long name (#8831) + doesn't find private module defined through macro (#8715) doesn't find private module defined through macro (#8715) + doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) + can use class var initializer in private type can use class var initializer in private type + doesn't find private constant from outside namespace doesn't find private constant from outside namespace +Init invocation + errors if files will be overwritten by a generated file errors if files will be overwritten by a generated file + prints error if a file is already present prints error if a file is already present + honors the custom set directory name honors the custom set directory name + doesn't error when asked to skip existing files doesn't error when asked to skip existing files + doesn't error if files will be overwritten by a generated file and --force is used doesn't error if files will be overwritten by a generated file and --force is used + produces valid yaml file produces valid yaml file +Semantic: initialize + doesn't type instance var as nilable if out doesn't type instance var as nilable if out + doesn't type instance var as nilable if not used in method call doesn't type instance var as nilable if not used in method call + doesn't type instance var as nilable if used after method call that doesn't read var doesn't type instance var as nilable if used after method call that doesn't read var + marks instance variable as nilable in initialize if using self in method marks instance variable as nilable in initialize if using self in method + types instance var as nilable if not always assigned types instance var as nilable if not always assigned + marks instance variable as nilable when using self in super marks instance variable as nilable when using self in super + finishes when analyzing recursive calls finishes when analyzing recursive calls + types instance var as nilable if assigned in block types instance var as nilable if assigned in block + types instance var as non-nilable if calls super and super defines it, with one level of indirection types instance var as non-nilable if calls super and super defines it, with one level of indirection + doesn't type ivar having initializer as nilable even if it is used before assigned inside initialize (#5112) doesn't type ivar having initializer as nilable even if it is used before assigned inside initialize (#5112) + doesn't type ivar as nilable if super call present and parent has already typed ivar (#4764) doesn't type ivar as nilable if super call present and parent has already typed ivar (#4764) + types instance var as nilable if used before assignment types instance var as nilable if used before assignment + types initializer of recursive generic type types initializer of recursive generic type + doesn't type instance var as nilable if assigned before method call doesn't type instance var as nilable if assigned before method call + types instance vars as nilable if doesn't invoke super with default arguments types instance vars as nilable if doesn't invoke super with default arguments + types instance var as non-nilable if calls super and super defines it types instance var as non-nilable if calls super and super defines it + doesn't type instance var as nilable if used after method call inside typeof doesn't type instance var as nilable if used after method call inside typeof + doesn't type instance var as nilable if used after global method call doesn't type instance var as nilable if used after global method call + doesn't type instance var as nilable if used after method call that assigns var doesn't type instance var as nilable if used after method call that assigns var + marks instance variable as nilable in initialize if using self marks instance variable as nilable in initialize if using self + types instance var as nilable if used after method call that reads var (2) types instance var as nilable if used after method call that reads var (2) + doesn't mark instance variable as nilable when using self.class doesn't mark instance variable as nilable when using self.class + types instance var as nilable if used after method call that reads var through other calls types instance var as nilable if used after method call that reads var through other calls + checks instance vars of included modules checks instance vars of included modules + types initializer of generic type after instantiated types initializer of generic type after instantiated + types instance var as not-nilable if assigned in block but previously assigned types instance var as not-nilable if assigned in block but previously assigned + marks instance variable as nilable in initialize if assigning self marks instance variable as nilable in initialize if assigning self + types instance vars as nilable if doesn't invoke super in initialize types instance vars as nilable if doesn't invoke super in initialize + doesn't mark instance variable as nilable when using self.class in method doesn't mark instance variable as nilable when using self.class in method + types instance var as nilable if used after method call that reads var types instance var as nilable if used after method call that reads var + errors on default new when using named arguments (#2245) errors on default new when using named arguments (#2245) + types instance vars as nilable if doesn't invoke super in initialize with deep subclass types instance vars as nilable if doesn't invoke super in initialize with deep subclass + errors if found matches for initialize but doesn't cover all (bug #204) errors if found matches for initialize but doesn't cover all (bug #204) + types instance var as nilable if used in first of two method calls types instance var as nilable if used in first of two method calls +Semantic: metaclass + types generic module metaclass types generic module metaclass + types Object class types Object class + can't reopen as struct can't reopen as struct + types Object and Class metaclasses types Object and Class metaclasses + types metaclass superclass types metaclass superclass + can't reopen as module can't reopen as module + types generic instance metaclass superclass types generic instance metaclass superclass + subtyping relations between metaclasses + non-generic classes non-generic classes + non-generic modules non-generic modules + generic modules (2) generic modules (2) + generic classes (1) generic classes (1) + generic modules (1) generic modules (1) + generic classes (3) generic classes (3) + generic modules (3) generic modules (3) + virtual metaclass type with virtual type (#12628) virtual metaclass type with virtual type (#12628) + generic classes (2) generic classes (2) + types Class class types Class class + types generic class metaclass types generic class metaclass + types generic metaclass superclass types generic metaclass superclass + types Reference metaclass types Reference metaclass +Semantic: is_a? + checks simple type with union checks simple type with union + restricts type inside if scope 1 restricts type inside if scope 1 + does is_a? from virtual metaclass to generic metaclass (#12302) does is_a? from virtual metaclass to generic metaclass (#12302) + restricts other types inside if else restricts other types inside if else + restricts type in else but lazily restricts type in else but lazily + doesn't fail on untyped is_a (#10317) doesn't fail on untyped is_a (#10317) + types if is_a? preceded by return if (preserves nops) types if is_a? preceded by return if (preserves nops) + applies filter inside block applies filter inside block + is bool is bool + restricts type inside if else when used with module type restricts type inside if else when used with module type + restricts type inside if scope 3 restricts type inside if scope 3 + restricts type inside if scope 2 restricts type inside if scope 2 + restricts in assignment restricts in assignment + applies negative condition filter if then is no return applies negative condition filter if then is no return + checks union with union checks union with union +.system + failing command failing command + successful command successful command +sh: line 1: commanddoesnotexist: command not found + command does not exist command does not exist + successful command with output successful command with output +Semantic: array + types array literal of int with splats types array literal of int with splats + types non-empty typed array literal of int types non-empty typed array literal of int + types array literal of union types array literal of union + types non-empty typed array literal of int types non-empty typed array literal of int + types array literal size correctly types array literal size correctly + types empty typed array literal of int32 types empty typed array literal of int32 + assignment in array literal works (#3195) assignment in array literal works (#3195) + types array literal with splats (2) types array literal with splats (2) + types array literal with splats types array literal with splats + types array literal of int types array literal of int +Code gen: proc + codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) + builds proc type from fun builds proc type from fun + call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises + accesses T in macros as a TupleLiteral accesses T in macros as a TupleLiteral + doesn't crash when taking a proc pointer that multidispatches on the top-level (#3822) doesn't crash when taking a proc pointer that multidispatches on the top-level (#3822) + call proc pointer of instance method call proc pointer of instance method + codegens nilable proc type (2) codegens nilable proc type (2) + calls proc pointer with union (passed by value) arg calls proc pointer with union (passed by value) arg + call simple proc literal with return call simple proc literal with return + saves receiver value of proc pointer `->var.foo` saves receiver value of proc pointer `->var.foo` + saves receiver value of proc pointer `->@ivar.foo` saves receiver value of proc pointer `->@ivar.foo` + codegens proc with another var codegens proc with another var + passes proc as &->expr to method that yields passes proc as &->expr to method that yields + call simple proc literal call simple proc literal + allows using proc arg name shadowing local variable allows using proc arg name shadowing local variable + allows proc type of enum type with base type allows proc type of enum type with base type + allows invoking a function with a subtype when defined as block spec allows invoking a function with a subtype when defined as block spec + codegens proc that references struct (bug) codegens proc that references struct (bug) + allows invoking proc literal with smaller type allows invoking proc literal with smaller type + takes pointerof function pointer takes pointerof function pointer + calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer + allows proc type of enum type allows proc type of enum type + codegens proc with union type that returns itself codegens proc with union type that returns itself + can assign proc that returns anything to proc that returns nil, using union type (#3655) can assign proc that returns anything to proc that returns nil, using union type (#3655) + codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type + doesn't crash when taking a proc pointer that multidispatches on a module (#3822) doesn't crash when taking a proc pointer that multidispatches on a module (#3822) + codegens nilable proc type dispatch (1) codegens nilable proc type dispatch (1) + codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) + codegens proc of generic type codegens proc of generic type + doesn't crash on #2196 doesn't crash on #2196 + builds nilable proc type from fun builds nilable proc type from fun + call proc literal with arguments call proc literal with arguments + executes proc pointer on primitive executes proc pointer on primitive + codegens nilable proc type (1) codegens nilable proc type (1) + makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference + closures var on ->var.call (#8584) closures var on ->var.call (#8584) + uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) + codegens proc that accepts a union and is called with a single type codegens proc that accepts a union and is called with a single type + allows redefining fun allows redefining fun + raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) + mangles strings in such a way they don't conflict with funs (#1006) mangles strings in such a way they don't conflict with funs (#1006) + gets proc pointer using virtual type (#1337) gets proc pointer using virtual type (#1337) + returns ProcPointer inside top-level fun (#14691) returns ProcPointer inside top-level fun (#14691) + casts from function pointer to proc casts from function pointer to proc + assigns nil and proc to nilable proc type assigns nil and proc to nilable proc type + call proc literal with return type call proc literal with return type + codegens proc that returns a virtual type codegens proc that returns a virtual type + passes block to another function (bug: mangling of both methods was the same) passes block to another function (bug: mangling of both methods was the same) + call proc pointer with args call proc pointer with args + codegens captured block that returns tuple codegens captured block that returns tuple + codegens nilable proc type dispatch (2) codegens nilable proc type dispatch (2) + codegens proc in instance var initialize (#3016) codegens proc in instance var initialize (#3016) + binds function pointer to associated call binds function pointer to associated call + allows invoking a function with a subtype allows invoking a function with a subtype + codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct + automatically casts proc that returns something to proc that returns void automatically casts proc that returns something to proc that returns void + allows proc pointer where self is a class allows proc pointer where self is a class + call proc pointer call proc pointer + saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` + doesn't crash when taking a proc pointer to a virtual type (#9823) doesn't crash when taking a proc pointer to a virtual type (#9823) + does new on proc type does new on proc type + gets proc to lib fun (#504) gets proc to lib fun (#504) + can assign proc that returns anything to proc that returns nil (#3655) can assign proc that returns anything to proc that returns nil (#3655) + can pass Proc(T) to Proc(Nil) in type restriction (#8964) can pass Proc(T) to Proc(Nil) in type restriction (#8964) + returns proc as function pointer inside top-level fun (#14691) returns proc as function pointer inside top-level fun (#14691) + allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically +Lexer string + lexes double numeral lexes double numeral + says syntax error on "\"\\uD800\"" says syntax error on "\"\\uD800\"" + raises when identifier doesn't start with a letter or number raises when identifier doesn't start with a letter or number + lexes string with unicode codepoint in curly multiple times lexes string with unicode codepoint in curly multiple times + lexes heredoc with spaces before close tag lexes heredoc with spaces before close tag + says syntax error on "\"\\u{}\"" says syntax error on "\"\\u{}\"" + lexes interpolations in heredocs lexes interpolations in heredocs + says syntax error on "\"\\u{DFFF}\"" says syntax error on "\"\\u{DFFF}\"" + lexes simple string with nested %( lexes simple string with nested %( + lexes string with slash lexes string with slash + lexes string with only newline lexes string with only newline + lexes regex string with escaped slash with %r(...) lexes regex string with escaped slash with %r(...) + lexes regex string with escaped space with /.../ lexes regex string with escaped space with /.../ + lexes simple string with nested %{ lexes simple string with nested %{ + says syntax error on "\"\\u{D800}\"" says syntax error on "\"\\u{D800}\"" + lexes string with interpolation lexes string with interpolation + lexes string with slash t lexes string with slash t + lexes string with newline lexes string with newline + assigns correct location after heredoc (#346) assigns correct location after heredoc (#346) + lexes simple string lexes simple string + lexes string with unicode codepoint lexes string with unicode codepoint + lexes slash with no-escape char lexes slash with no-escape char + lexes simple string with %( lexes simple string with %( + says syntax error on "\"\\uDFFF\"" says syntax error on "\"\\uDFFF\"" + says syntax error on "\"\\u{110000}\"" says syntax error on "\"\\u{110000}\"" + lexes string with backslash lexes string with backslash + lexes heredoc lexes heredoc + lexes simple string with nested %< lexes simple string with nested %< + lexes string with interpolation with double numeral lexes string with interpolation with double numeral + lexes regex string with escaped slash with /.../ lexes regex string with escaped slash with /.../ + lexes heredoc with empty line lexes heredoc with empty line + raises on unexpected EOF while lexing heredoc raises on unexpected EOF while lexing heredoc + lexes heredoc with \r\n lexes heredoc with \r\n + lexes backtick string lexes backtick string + lexes string with slash quote lexes string with slash quote + lexes regex string with special chars with /.../ lexes regex string with special chars with /.../ + raises on unterminated heredoc raises on unterminated heredoc + lexes simple string with nested %[ lexes simple string with nested %[ + lexes string with numeral lexes string with numeral + lexes regex string lexes regex string + lexes string with unicode codepoint in curly lexes string with unicode codepoint in curly + lexes regex string with escaped space with %r(...) lexes regex string with escaped space with %r(...) + lexes simple string with %| lexes simple string with %| + lexes regex string with special chars with %r(...) lexes regex string with special chars with %r(...) + lexes string with literal newline lexes string with literal newline + says syntax error on "\"\\uFEDZ\"" says syntax error on "\"\\uFEDZ\"" +Lexer string array + using [ as delimiter + lexes simple string array lexes simple string array + using | as delimiter + lexes simple string array lexes simple string array + lexes simple string array lexes simple string array + using < as delimiter + lexes simple string array lexes simple string array + using { as delimiter + lexes simple string array lexes simple string array + lexes string array with new line gives correct column for next token lexes string array with new line gives correct column for next token + lexes string array with new line lexes string array with new line +Normalize: unless + normalizes unless normalizes unless +Code gen: C ABI + passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) passes struct between 64 and 128 bits (for real) + promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) promotes variadic args (float to double) + returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) returns struct less than 64 bits (for real) + promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) promotes variadic args (i16 to i32) (#9742) + passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) passes struct bigger than 128 bits (for real) + passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) passes struct less than 64 bits (for real) + passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) passes struct after many other args when returning a large struct (sret return type) + accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) accepts large struct in a callback (for real) + returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret returns struct bigger than 128 bits with sret + promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) promotes variadic args (u16 to i32) (#9742) + passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) passes struct after many other args (for real) + promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) promotes variadic args (i8 to i32) (#9742) + promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) promotes variadic args (u8 to i32) (#9742) + returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) returns struct between 64 and 128 bits (for real) +Code gen: class + reads a virtual type instance var reads a virtual type instance var + codegens class method codegens class method + calls class method without self calls class method without self + assigns type to reference union type assigns type to reference union type + resolves type declaration when accessing instance var (#348) resolves type declaration when accessing instance var (#348) + never considers read instance var as closure (#12181) never considers read instance var as closure (#12181) + doesn't crash on abstract class never instantiated (#2840) doesn't crash on abstract class never instantiated (#2840) + works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) + codegens method of class union including Int (#1476) codegens method of class union including Int (#1476) + allows fixing an instance variable's type allows fixing an instance variable's type + doesn't crash on #1216 with pointerof doesn't crash on #1216 with pointerof + codegens new which calls initialize codegens new which calls initialize + invokes class method inside instance method (#1119) invokes class method inside instance method (#1119) + does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) + doesn't crash on #1216 doesn't crash on #1216 + runs instance variable initializer at the class level runs instance variable initializer at the class level + does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) + codegens assignment of generic metaclasses (2) (#10394) codegens assignment of generic metaclasses (2) (#10394) + makes .class always be a virtual type even if no subclasses makes .class always be a virtual type even if no subclasses + does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class + reads a union type instance var (reference union, first type) reads a union type instance var (reference union, first type) + codegens virtual metaclass union bug (#2597) codegens virtual metaclass union bug (#2597) + runs instance variable initializer at the class level, for generic type runs instance variable initializer at the class level, for generic type + codegens virtual generic class instance metaclass (#3819) codegens virtual generic class instance metaclass (#3819) + transfers initializer from module to generic class transfers initializer from module to generic class + calls method on Class class calls method on Class class + codegens singleton (#718) codegens singleton (#718) + does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class + codegens bug #168 codegens bug #168 + codegens assignment of generic metaclasses (4) (#10394) codegens assignment of generic metaclasses (4) (#10394) + codegens recursive type codegens recursive type + doesn't skip zero initializers (#3272) doesn't skip zero initializers (#3272) + codegens assignment of generic metaclasses, base is non-generic (2) (#10394) codegens assignment of generic metaclasses, base is non-generic (2) (#10394) + doesn't crash if not using undefined instance variable in superclass doesn't crash if not using undefined instance variable in superclass + does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) + codegens call to same instance codegens call to same instance + codegens method call of instance var codegens method call of instance var + codegens instance var codegens instance var + codegens assignment of generic metaclasses (3) (#10394) codegens assignment of generic metaclasses (3) (#10394) + allows using self in class scope allows using self in class scope + gets class of virtual type gets class of virtual type + uses number type var uses number type var + codegens class with recursive tuple to class (#4520) codegens class with recursive tuple to class (#4520) + codegens assignment of generic metaclasses, base is non-generic (1) (#10394) codegens assignment of generic metaclasses, base is non-generic (1) (#10394) + codegens initialize with instance var codegens initialize with instance var + reads other instance var reads other instance var + calls class method without self (2) calls class method without self (2) + codegens virtual call that calls another method codegens virtual call that calls another method + reads a union type instance var (reference union, second type) reads a union type instance var (reference union, second type) + transfers initializer from generic module to generic class transfers initializer from generic module to generic class + builds generic class bug builds generic class bug + codegens method from another method without obj and accesses instance vars codegens method from another method without obj and accesses instance vars + changes instance variable in method (ssa bug) changes instance variable in method (ssa bug) + reads a union type instance var (mixed union, second type) reads a union type instance var (mixed union, second type) + reads a union type instance var (mixed union, first type) reads a union type instance var (mixed union, first type) + codegens virtual method of generic class codegens virtual method of generic class + can assign virtual metaclass to virtual metaclass (#3007) can assign virtual metaclass to virtual metaclass (#3007) + allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope + doesn't crash on #1216 (reduced) doesn't crash on #1216 (reduced) + codegens assignment of generic metaclasses (1) (#10394) codegens assignment of generic metaclasses (1) (#10394) + transfers initializer from generic module to non-generic class transfers initializer from generic module to non-generic class + runs with nilable instance var runs with nilable instance var + codegens virtual class method codegens virtual class method + doesn't skip false initializers (#3272) doesn't skip false initializers (#3272) + allows initializing var with constant allows initializing var with constant + doesn't crash on instance variable assigned a proc, and never instantiated (#923) doesn't crash on instance variable assigned a proc, and never instantiated (#923) + runs with nil instance var when inheriting runs with nil instance var when inheriting + notifies superclass recursively on inheritance (#576) notifies superclass recursively on inheritance (#576) + works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) + can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) +Code gen: multi assign + supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) supports 1 to n assignment, raises if out of bounds (1) + without strict_multi_assign + supports 1 to n assignment supports 1 to n assignment + doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count doesn't raise if value size in 1 to n assignment doesn't match target count + supports m to n assignment, with splat on left-hand side (2) supports m to n assignment, with splat on left-hand side (2) + supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) supports 1 to n assignment, raises if out of bounds (2) + supports 1 to n assignment, with splat on left-hand side (2) supports 1 to n assignment, with splat on left-hand side (2) + strict_multi_assign + raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count raises if value size in 1 to n assignment doesn't match target count + supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment supports 1 to n assignment + supports n to n assignment supports n to n assignment + supports m to n assignment, splat is empty tuple (3) supports m to n assignment, splat is empty tuple (3) + supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) supports 1 to n assignment, splat is empty (1) + supports 1 to n assignment, with splat on left-hand side (3) supports 1 to n assignment, with splat on left-hand side (3) + supports m to n assignment, splat is empty tuple (1) supports m to n assignment, splat is empty tuple (1) + supports m to n assignment, with splat on left-hand side (1) supports m to n assignment, with splat on left-hand side (1) + supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) supports 1 to n assignment, with splat on left-hand side (1) + supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short supports 1 to n assignment, raises if too short + supports 1 to n assignment, splat is empty (3) supports 1 to n assignment, splat is empty (3) + supports m to n assignment, splat is empty tuple (2) supports m to n assignment, splat is empty tuple (2) + supports m to n assignment, with splat on left-hand side (3) supports m to n assignment, with splat on left-hand side (3) + supports 1 to n assignment, splat is empty (2) supports 1 to n assignment, splat is empty (2) +Crystal::JSONHierarchyPrinter + works works +Code gen: tuple + passes empty tuple and empty named tuple to a method (#2852) passes empty tuple and empty named tuple to a method (#2852) + codegens tuple [2]? codegens tuple [2]? + codegens tuple metaclass [0..0] codegens tuple metaclass [0..0] + codegens tuple metaclass [3..2]? codegens tuple metaclass [3..2]? + codegens tuple [0] codegens tuple [0] + codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) + downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types + assigns tuple to compatible tuple assigns tuple to compatible tuple + merges two tuple types of same size (1) merges two tuple types of same size (1) + codegens tuple metaclass [2]? codegens tuple metaclass [2]? + codegens tuple [0..1] codegens tuple [0..1] + upcasts tuple inside union to union with compatible tuple upcasts tuple inside union to union with compatible tuple + upcasts tuple union to compatible tuple upcasts tuple union to compatible tuple + assigns tuple union to compatible tuple assigns tuple union to compatible tuple + assigns two same-size tuple types to a same var (#3132) assigns two same-size tuple types to a same var (#3132) + accesses T and creates instance from it accesses T and creates instance from it + codegens tuple [0..2] codegens tuple [0..2] + codegens tuple [0..0]? codegens tuple [0..0]? + codegens tuple [0..1]? codegens tuple [0..1]? + allows tuple covariance allows tuple covariance + allows malloc pointer of tuple allows malloc pointer of tuple + codegens tuple [1] (2) codegens tuple [1] (2) + codegens tuple [2..2]? codegens tuple [2..2]? + codegens tuple class codegens tuple class + codegens tuple metaclass [1] codegens tuple metaclass [1] + assigns tuple inside union to union with compatible tuple assigns tuple inside union to union with compatible tuple + merges two tuple types of same size (2) merges two tuple types of same size (2) + codegens tuple metaclass [0] codegens tuple metaclass [0] + codegens tuple [1..1] codegens tuple [1..1] + codegens tuple [1..0]? codegens tuple [1..0]? + codegens tuple [1] codegens tuple [1] + gets size at compile time gets size at compile time + upcasts tuple inside compatible tuple upcasts tuple inside compatible tuple + provides T as a tuple literal provides T as a tuple literal + codegens tuple [0..0] codegens tuple [0..0] + downcasts union inside tuple to value (#3907) downcasts union inside tuple to value (#3907) + codegens splats inside tuples codegens splats inside tuples + codegens tuple [0]? codegens tuple [0]? + codegens tuple [3..2]? codegens tuple [3..2]? + codegens tuple [1]? codegens tuple [1]? + codegens tuple [1..0] codegens tuple [1..0] + codegens tuple metaclass [0..1] codegens tuple metaclass [0..1] + downcasts union to mixed tuple type downcasts union to mixed tuple type + codegens tuple [-3..2]? codegens tuple [-3..2]? + codegens tuple [0..2]? codegens tuple [0..2]? + codegens tuple [1..1]? codegens tuple [1..1]? + codegens tuple [2..2] codegens tuple [2..2] + codegens union of tuple of float with tuple of tuple of float codegens union of tuple of float with tuple of tuple of float + codegens tuple metaclass [1..0] codegens tuple metaclass [1..0] + passed tuple to def passed tuple to def Crystal::Repl::Interpreter special vars - sets special var inside call inside block (#12250) sets special var inside call inside block (#12250) does special var that's a reference inside block does special var that's a reference inside block - does special var that's a reference for multidispatch does special var that's a reference for multidispatch + does special var that's a struct does special var that's a struct does special var that's a reference does special var that's a reference + sets special var inside call inside block (#12250) sets special var inside call inside block (#12250) + does special var that's a reference for multidispatch does special var that's a reference for multidispatch does special var that's a reference when there are optional arguments does special var that's a reference when there are optional arguments - does special var that's a struct does special var that's a struct +Code gen: sizeof + gets sizeof int gets sizeof int + can use instance_sizeof of virtual type can use instance_sizeof of virtual type + doesn't precompute sizeof of module (#7741) doesn't precompute sizeof of module (#7741) + can use instance_sizeof in type argument can use instance_sizeof in type argument + gets sizeof union gets sizeof union + gets instance_sizeof a generic type with type vars gets instance_sizeof a generic type with type vars + gets sizeof NoReturn gets sizeof NoReturn + alignof + gets alignof struct gets alignof struct + gets alignof union gets alignof union + alignof mixed union is not less than alignof its variant types alignof mixed union is not less than alignof its variant types + gets alignof class gets alignof class + gets alignof primitive types gets alignof primitive types + instance_alignof + gets instance_alignof a generic type with type vars gets instance_alignof a generic type with type vars + gets instance_alignof class gets instance_alignof class + doesn't precompute sizeof of abstract struct (#7741) doesn't precompute sizeof of abstract struct (#7741) + can use sizeof in type argument (2) can use sizeof in type argument (2) + can use sizeof of virtual type can use sizeof of virtual type + gets sizeof Bool (#8272) gets sizeof Bool (#8272) + returns correct sizeof for abstract struct (#4319) returns correct sizeof for abstract struct (#4319) + gets sizeof struct gets sizeof struct + gets sizeof Void gets sizeof Void + gets instance_sizeof class gets instance_sizeof class + gets sizeof Nil (#7644) gets sizeof Nil (#7644) + can use sizeof in type argument (1) can use sizeof in type argument (1) + gets sizeof class gets sizeof class +Crystal::Doc::Method + doc + gets doc from underlying method gets doc from underlying method + inherits doc from ancestor (no extra comment) inherits doc from ancestor (no extra comment) + inherits doc from ancestor (use :inherit:) inherits doc from ancestor (use :inherit:) + trailing comment is not part of a doc comment trailing comment is not part of a doc comment + inherits doc from previous def (no extra comment) inherits doc from previous def (no extra comment) + inherits doc from ancestor (use :inherit: plus more content) inherits doc from ancestor (use :inherit: plus more content) + trailing comment is not a doc comment trailing comment is not a doc comment + args_to_s + shows simple args shows simple args + shows underscore restriction shows underscore restriction + shows double splat args shows double splat args + shows return type restriction shows return type restriction + shows args and return type restriction shows args and return type restriction + shows block args with underscore shows block args with underscore + shows splat args shows splat args + shows external name of arg shows external name of arg + shows block args if a def has `yield` shows block args if a def has `yield` + shows external name of arg with quotes and escaping shows external name of arg with quotes and escaping + shows typeof restriction of arg with highlighting shows typeof restriction of arg with highlighting + shows default value of arg with highlighting shows default value of arg with highlighting + shows block args shows block args +Semantic: offsetof + can be used with generic types can be used with generic types + errors on undefined instance variable errors on undefined instance variable + errors on offsetof element of uninstantiated generic type errors on offsetof element of uninstantiated generic type + gives error if using offsetof on Tuples with instance variables gives error if using offsetof on Tuples with instance variables + gives error if using offsetof on something that's neither a class, a struct nor a Tuple gives error if using offsetof on something that's neither a class, a struct nor a Tuple + gives error if using offsetof on something that can't have instance variables gives error if using offsetof on something that can't have instance variables + gives error if using offsetof on Tuples with indexes greater than tuple size gives error if using offsetof on Tuples with indexes greater than tuple size + types offsetof types offsetof + gives error if using offsetof on non-Tuples with an index gives error if using offsetof on non-Tuples with an index + can be used with classes can be used with classes + gives error if using offsetof on Tuples with negative indexes gives error if using offsetof on Tuples with negative indexes + errors on typeof inside offsetof expression errors on typeof inside offsetof expression +Crystal::TextHierarchyPrinter + shows correct total size of generic class if known shows correct total size of generic class if known + works works + shows correct size for Bool member shows correct size for Bool member + shows correct size for Proc inside extern struct shows correct size for Proc inside extern struct + shows correct size for members with bound types shows correct size for members with bound types +Code gen: method_missing + does method_missing macro without args (with call) does method_missing macro without args (with call) + works with named arguments (#3654) works with named arguments (#3654) + does method_missing with assignment (bug) does method_missing with assignment (bug) + does method_missing macro with top level method involved does method_missing macro with top level method involved + does method_missing macro with block does method_missing macro with block + does method_missing macro with virtual type (3) does method_missing macro with virtual type (3) + does method_missing macro with args (with call) does method_missing macro with args (with call) + does method_missing macro with virtual type (7) does method_missing macro with virtual type (7) + does method_missing macro with virtual type (2) does method_missing macro with virtual type (2) + does method_missing macro without args does method_missing macro without args + finds method_missing with 'with ... yield' finds method_missing with 'with ... yield' + does method_missing macro with block but not using it does method_missing macro with block but not using it + does method_missing macro with virtual type (1) does method_missing macro with virtual type (1) + works with named arguments that aren't legal variable names (#10381) works with named arguments that aren't legal variable names (#10381) + does method_missing macro with included module does method_missing macro with included module + does method_missing with assignment (2) (bug) does method_missing with assignment (2) (bug) + does method_missing macro with virtual type (5) does method_missing macro with virtual type (5) + does method_missing macro with virtual type (8) does method_missing macro with virtual type (8) + does method_missing generating method does method_missing generating method + does method_missing macro with virtual type (4) does method_missing macro with virtual type (4) + does method_missing macro with virtual type (6) does method_missing macro with virtual type (6) + forwards forwards + does method_missing macro with module involved does method_missing macro with module involved + does method_missing macro with args does method_missing macro with args +Semantic: macro overload + doesn't overwrite last macro definition if named args differs doesn't overwrite last macro definition if named args differs +Semantic: not + filters types inside if/else filters types inside if/else + filters types inside if filters types inside if + doesn't restrict and in while (#4243) doesn't restrict and in while (#4243) + doesn't restrict and doesn't restrict and + types not types not + types not as NoReturn if exp is NoReturn types not as NoReturn if exp is NoReturn + filters types with !is_a? filters types with !is_a? +Code gen: virtual type + codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types + returns type with virtual type def type returns type with virtual type def type + codegens virtual call with explicit self codegens virtual call with explicit self + correctly dispatch call with block when the obj is a virtual type correctly dispatch call with block when the obj is a virtual type + dispatches on virtual metaclass (1) dispatches on virtual metaclass (1) + calls class method 3 calls class method 3 + codegens virtual call with explicit self and nilable type codegens virtual call with explicit self and nilable type + call base overwritten method call base overwritten method + initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated + codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type + codegens allocate for virtual type with custom new codegens allocate for virtual type with custom new + codegens virtual method of abstract metaclass codegens virtual method of abstract metaclass + dispatch call with nilable virtual arg dispatch call with nilable virtual arg + dispatches on virtual metaclass (3) dispatches on virtual metaclass (3) + lookup instance variables in parent types lookup instance variables in parent types + doesn't lookup in Value+ when virtual type is Object+ doesn't lookup in Value+ when virtual type is Object+ + call overwritten method call overwritten method + call base method call base method + codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) + calls class method 1 calls class method 1 + dispatches on virtual metaclass (2) dispatches on virtual metaclass (2) + codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type + assign instance variable in virtual type assign instance variable in virtual type + casts virtual type to union casts virtual type to union + calls class method 2 calls class method 2 + casts union to virtual casts union to virtual + codegens new twice for virtual codegens new twice for virtual + codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type + casts virtual type to base virtual type casts virtual type to base virtual type + casts metaclass union type to virtual metaclass type (#6298) casts metaclass union type to virtual metaclass type (#6298) + dispatch call with virtual type argument dispatch call with virtual type argument + can belong to union can belong to union + codegens new for simple type, then for virtual codegens new for simple type, then for virtual + codegens non-virtual call that calls virtual call to another virtual call codegens non-virtual call that calls virtual call to another virtual call +Crystal::TablePrint + rows with horizontal separators rows with horizontal separators + single row with separator single row with separator + single cell single cell + multiple rows with separator multiple rows with separator + aligns cell content aligns cell content + colspan a cell that fits the available size colspan a cell that fits the available size + aligns columns borders aligns columns borders +Code gen: case + codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition + codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call + does case when with metaclass does case when with metaclass + codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions + codegens case with class codegens case with class + codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns + codegens case when constant bug (#1028) codegens case when constant bug (#1028) + codegens value-less case codegens value-less case + codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else + codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else +Normalize: multi assign + normalizes 1 to n, with splat on left-hand side, splat before other targets normalizes 1 to n, with splat on left-hand side, splat before other targets + normalizes m to n, with splat on left-hand side, splat is non-empty normalizes m to n, with splat on left-hand side, splat is non-empty + normalizes m to n, with *_ on left-hand side (3) normalizes m to n, with *_ on left-hand side (3) + without strict_multi_assign + normalizes 1 to n with [] normalizes 1 to n with [] + normalizes 1 to n with call normalizes 1 to n with call + normalizes 1 to n normalizes 1 to n + normalizes n to splat on left-hand side normalizes n to splat on left-hand side + normalizes n to *_ on left-hand side normalizes n to *_ on left-hand side + normalizes n to n with call normalizes n to n with call + strict_multi_assign + normalizes 1 to n with call normalizes 1 to n with call + normalizes 1 to n with [] normalizes 1 to n with [] + normalizes 1 to n normalizes 1 to n + normalizes n to n with [] normalizes n to n with [] + normalizes 1 to splat on left-hand side normalizes 1 to splat on left-hand side + normalizes m to n, with *_ on left-hand side (1) normalizes m to n, with *_ on left-hand side (1) + normalizes 1 to n, with splat on left-hand side, splat after other targets normalizes 1 to n, with splat on left-hand side, splat after other targets + normalizes n to n normalizes n to n + normalizes m to n, with splat on left-hand side, splat is empty normalizes m to n, with splat on left-hand side, splat is empty + normalizes 1 to n, with *_ on left-hand side (1) normalizes 1 to n, with *_ on left-hand side (1) + normalizes 1 to *_ on left-hand side normalizes 1 to *_ on left-hand side + normalizes 1 to n, with splat on left-hand side normalizes 1 to n, with splat on left-hand side + normalizes 1 to n, with *_ on left-hand side (3) normalizes 1 to n, with *_ on left-hand side (3) + normalizes 1 to n, with *_ on left-hand side (2) normalizes 1 to n, with *_ on left-hand side (2) + normalizes m to n, with *_ on left-hand side (2) normalizes m to n, with *_ on left-hand side (2) +Semantic: yield with scope + yields virtual type (#2171) (2) yields virtual type (#2171) (2) + it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope it invokes global method inside block of yield scope + it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method it uses self for instance method + yields with dispatch (#2171) (1) yields with dispatch (#2171) (1) + uses instance variable of enclosing scope uses instance variable of enclosing scope + uses scope in global method uses scope in global method uses scope in global method uses scope in global method uses scope in global method uses scope in global method uses scope in global method uses scope in global method uses scope in global method uses scope in global method + uses method of with object uses method of with object + doesn't explode if specifying &block but never using it (#181) doesn't explode if specifying &block but never using it (#181) + generate right code when yielding struct as scope generate right code when yielding struct as scope + uses method of enclosing scope uses method of enclosing scope + uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method uses scope in instance method Crystal::Repl::Interpreter - autocast - autocasts integer var to integer (#12560) autocasts integer var to integer (#12560) - autocasts float32 var to float64 (#12560) autocasts float32 var to float64 (#12560) - autocasts symbol to enum in multidispatch (#11782) autocasts symbol to enum in multidispatch (#11782) - autocasts int in multidispatch autocasts int in multidispatch - autocasts number literal to float autocasts number literal to float - autocasts symbol to enum in ivar initializer (#12216) autocasts symbol to enum in ivar initializer (#12216) - autocasts symbol to enum autocasts symbol to enum - autocasts integer var to float (#12560) autocasts integer var to float (#12560) - autocasts number literal to integer autocasts number literal to integer -Code gen: enum - can use macro calls inside enum value, with receiver (#424) can use macro calls inside enum value, with receiver (#424) - codegens enum bitflags None codegens enum bitflags None - codegens enum without explicit value codegens enum without explicit value - codegens enum bitflags (4) codegens enum bitflags (4) - can define flags enum : UInt128 with 128 values can define flags enum : UInt128 with 128 values - codegens enum bitflags (2) codegens enum bitflags (2) - does ~ at compile time for enum member does ~ at compile time for enum member - creates enum from value creates enum from value - can define flags enum : UInt128 with compile-time interpreted values can define flags enum : UInt128 with compile-time interpreted values - codegens enum codegens enum - automatically defines question method for each enum member (false case) automatically defines question method for each enum member (false case) - codegens enum bitflags (1) codegens enum bitflags (1) - automatically defines question method for each enum member (flags, true case) automatically defines question method for each enum member (flags, true case) - automatically defines question method for each enum member (true case) automatically defines question method for each enum member (true case) - can redefine Enum.new and use previous_def can redefine Enum.new and use previous_def - adds a none? method to flags enum adds a none? method to flags enum - codegens enum All redefined codegens enum All redefined - codegens enum None redefined codegens enum None redefined - uses enum value before declaration (hoisting) uses enum value before declaration (hoisting) - can use macro calls inside enum value (#424) can use macro calls inside enum value (#424) - codegens enum bitflags All codegens enum bitflags All - can define flags enum : UInt64 with more than 32 values (#7268) can define flags enum : UInt64 with more than 32 values (#7268) - allows class vars in enum allows class vars in enum - codegens enum value codegens enum value - automatically defines question method for each enum member (flags, false case) automatically defines question method for each enum member (flags, false case) - casts All value to base type casts All value to base type - can use macro calls inside enum value, macro defined outside enum (#424) can use macro calls inside enum value, macro defined outside enum (#424) -Crystal::Playground::Agent - should send json messages and return inspected value should send json messages and return inspected value -Compiler - has a valid version has a valid version - treats all arguments post-filename as program arguments treats all arguments post-filename as program arguments - compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file - runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename -Normalize: range literal - normalizes not exclusive normalizes not exclusive - normalizes exclusive normalizes exclusive + symbol + symbol equality symbol equality + Symbol#to_i Symbol#to_i + Symbol#to_s Symbol#to_s +Code gen: if + doesn't crash no NoReturn var (true left cond) (#1823) doesn't crash no NoReturn var (true left cond) (#1823) + codes if with two whiles codes if with two whiles + codegens if without an else with false codegens if without an else with false + codegens if of nilable type in else 3 codegens if of nilable type in else 3 + codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter + codegens if inside def without an else with true codegens if inside def without an else with true + codegens if with int codegens if with int + doesn't crash with if !is_a? using var in then doesn't crash with if !is_a? using var in then + codegens if with nil codegens if with nil + considers or truthy/falsey right considers or truthy/falsey right + codegen if with union type and else without type codegen if with union type and else without type + codegens if without an else with true codegens if without an else with true + codegens if of nilable type in then 2 codegens if of nilable type in then 2 + codegens if with union codegens if with union + codegens nested if with var (ssa bug) codegens nested if with var (ssa bug) + codegens if of nilable type in then codegens if of nilable type in then + codegens if with an else with true codegens if with an else with true + codegens #3104 codegens #3104 + codegens if with pointer 0x100000000 pointer codegens if with pointer 0x100000000 pointer + doesn't crash no NoReturn var (non-true left cond) (#1823) doesn't crash no NoReturn var (non-true left cond) (#1823) + codegens if with return in both branches codegens if with return in both branches + codegen if inside if codegen if inside if + codegens if with virtual codegens if with virtual + codegens if with an else with false codegens if with an else with false + codegen if with nested if that returns codegen if with nested if that returns + codegens if value from then codegens if value from then + codegen if with union type and then without type codegen if with union type and then without type + codegens if with return and no else codegens if with return and no else + doesn't crash with if !var using var in else doesn't crash with if !var using var in else + restricts with || always falsey restricts with || always falsey + codegens if of nilable type in else codegens if of nilable type in else + codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises + codegens bug #1729 codegens bug #1729 + doesn't generate truthy if branch if doesn't need value (bug) doesn't generate truthy if branch if doesn't need value (bug) +Restrictions + errors if using typeof inside generic type errors if using typeof inside generic type + works with static array that uses underscore works with static array that uses underscore + works with generic class metaclass vs. generic class metaclass works with generic class metaclass vs. generic class metaclass + restricts aliased typedef type (#9474) restricts aliased typedef type (#9474) + doesn't error if using NamedTuple with no args doesn't error if using NamedTuple with no args + sets number as unbound generic type var (#13110) sets number as unbound generic type var (#13110) + works with generic class metaclass vs. generic instance class metaclass works with generic class metaclass vs. generic instance class metaclass + matches number in bound free variable (#13605) matches number in bound free variable (#13605) + works with static array (#637) works with static array (#637) + restricts class union type to overloads with classes restricts class union type to overloads with classes + errors on T::Type that's union when used from type restriction errors on T::Type that's union when used from type restriction + errors if using typeof errors if using typeof + errors if using typeof in block restriction errors if using typeof in block restriction + restricts class union type to overloads with classes (2) restricts class union type to overloads with classes (2) + does not treat single path as free variable when given number (1) (#11859) does not treat single path as free variable when given number (1) (#11859) + doesn't error if using Tuple with no args doesn't error if using Tuple with no args + restriction_of? + Metaclass vs Metaclass + keeps typed Metaclass before untyped Metaclass keeps typed Metaclass before untyped Metaclass + inserts typed Metaclass before untyped Metaclass inserts typed Metaclass before untyped Metaclass + Path vs NumberLiteral + inserts number literal before constant of same value with generic arguments inserts number literal before constant of same value with generic arguments + inserts constant before number literal of same value with generic arguments inserts constant before number literal of same value with generic arguments + Union + handles redefinitions (2) (#12330) handles redefinitions (2) (#12330) + handles redefinitions (1) (#12330) handles redefinitions (1) (#12330) + orders union before generic (#12330) orders union before generic (#12330) + Generic vs Path + keeps typed Generic before untyped Path keeps typed Generic before untyped Path + inserts untyped Generic before untyped Path inserts untyped Generic before untyped Path + inserts typed Generic before untyped Path inserts typed Generic before untyped Path + inserts untyped Generic before untyped Path (2) inserts untyped Generic before untyped Path (2) + keeps untyped Generic before untyped Path keeps untyped Generic before untyped Path + Path vs Path + inserts typed Path before untyped Path inserts typed Path before untyped Path + keeps typed Path before untyped Path keeps typed Path before untyped Path + GenericClassType vs GenericClassInstanceType + inserts GenericClassInstanceType before GenericClassType inserts GenericClassInstanceType before GenericClassType + works with classes in different namespaces works with classes in different namespaces + doesn't mix different generic classes doesn't mix different generic classes + keeps GenericClassInstanceType before GenericClassType keeps GenericClassInstanceType before GenericClassType + Metaclass vs Path + keeps metaclass before Value keeps metaclass before Value + doesn't error if path is undefined and method is not called (2) (#12516) doesn't error if path is undefined and method is not called (2) (#12516) + keeps metaclass before Class keeps metaclass before Class + inserts metaclass before Class inserts metaclass before Class + inserts metaclass before Object inserts metaclass before Object + doesn't error if path is undefined and method is not called (1) (#12516) doesn't error if path is undefined and method is not called (1) (#12516) + inserts metaclass before Value inserts metaclass before Value + keeps metaclass before Object keeps metaclass before Object + Generic vs Generic + inserts typed Generic before untyped Generic inserts typed Generic before untyped Generic + keeps typed Generic before untyped Generic keeps typed Generic before untyped Generic + NamedTuple vs NamedTuple + doesn't mix incompatible NamedTuples (#10238) doesn't mix incompatible NamedTuples (#10238) + keeps more specialized NamedTuple before less specialized one keeps more specialized NamedTuple before less specialized one + inserts more specialized NamedTuple before less specialized one inserts more specialized NamedTuple before less specialized one + Underscore vs Path + keeps underscore after Path (#12854) keeps underscore after Path (#12854) + works with splats and modules, under -Dpreview_overload_order (#12854) works with splats and modules, under -Dpreview_overload_order (#12854) + inserts Path before underscore (#12854) inserts Path before underscore (#12854) + free variables + keeps path before free variable with same name keeps path before free variable with same name + keeps constant before free variable with same name keeps constant before free variable with same name + inserts constant before free variable with same name inserts constant before free variable with same name + inserts path before free variable with same name inserts path before free variable with same name + keeps path before free variable even if free var resolves to a more specialized type keeps path before free variable even if free var resolves to a more specialized type + inserts path before free variable even if free var resolves to a more specialized type inserts path before free variable even if free var resolves to a more specialized type + allows passing recursive type to free var (#1076) allows passing recursive type to free var (#1076) + errors if using free var without forall errors if using free var without forall + makes metaclass subclass pass parent metaclass restriction (#2079) makes metaclass subclass pass parent metaclass restriction (#2079) + errors if using NamedTuple with positional args errors if using NamedTuple with positional args + errors if using Tuple with named args errors if using Tuple with named args + errors if can't find type on lookup with nested type errors if can't find type on lookup with nested type + errors if can't find type on lookup errors if can't find type on lookup + restricts virtual metaclass type against metaclass (#3438) restricts virtual metaclass type against metaclass (#3438) + passes #278 passes #278 + matches alias against alias in block type matches alias against alias in block type + matches virtual type against alias matches virtual type against alias + self always matches instance type in return type self always matches instance type in return type + errors on T::Type that's a union when used from block type restriction errors on T::Type that's a union when used from block type restriction + restrict + restricts module with another module restricts module with another module + restricts type with same type restricts type with same type + restricts type with superclass restricts type with superclass + restricts generic module instance with class restricts generic module instance with class + restricts virtual generic class against uninstantiated generic subclass (1) restricts virtual generic class against uninstantiated generic subclass (1) + restricts virtual generic class against uninstantiated generic subclass (2) restricts virtual generic class against uninstantiated generic subclass (2) + restricts type with another type restricts type with another type + restricts generic module instance with another generic module instance restricts generic module instance with another generic module instance + restricts virtual type with included module 1 restricts virtual type with included module 1 + restricts virtual type with included module 2 restricts virtual type with included module 2 + restricts class against uninstantiated generic base class through multiple inheritance (2) (#9660) restricts class against uninstantiated generic base class through multiple inheritance (2) (#9660) + restricts module through generic include (#4287) restricts module through generic include (#4287) + restricts type with included module restricts type with included module + restricts class against uninstantiated generic base class through multiple inheritance (1) (#9660) restricts class against uninstantiated generic base class through multiple inheritance (1) (#9660) + restricts generic module instance with another module restricts generic module instance with another module + works with generic compared to fixed (primitive) type works with generic compared to fixed (primitive) type + does not treat single path as free variable when given number (2) (#11859) does not treat single path as free variable when given number (2) (#11859) + errors if using typeof in block restriction errors if using typeof in block restriction + should not let GenericChild(Base) pass as a GenericBase(Child) (#1294) should not let GenericChild(Base) pass as a GenericBase(Child) (#1294) + self always matches instance type in restriction self always matches instance type in restriction + matches free variable for type variable matches free variable for type variable + sets number as free variable (#2699) sets number as free variable (#2699) + works with union against unions of generics works with union against unions of generics +Codegen: extern struct + doesn't crash with proc with extern struct that's a closure doesn't crash with proc with extern struct that's a closure + declares extern union, sets and gets instance var declares extern union, sets and gets instance var + invokes proc with extern struct with sret invokes proc with extern struct with sret + invokes proc with extern struct invokes proc with extern struct + codegens extern proc call twice (#4982) codegens extern proc call twice (#4982) + declares extern struct with no constructor, assigns var declares extern struct with no constructor, assigns var + sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct + codegens proc that takes and returns large extern struct by value codegens proc that takes and returns large extern struct by value + codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI + codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil + codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI + declares extern union with no constructor declares extern union with no constructor + sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union + declares extern struct, sets and gets instance var declares extern struct, sets and gets instance var + declares extern struct with no constructor declares extern struct with no constructor + codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret + codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI + codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) +Semantic: annotation + errors if wanting to add type inside annotation (2) (#8614) errors if wanting to add type inside annotation (2) (#8614) + #annotation + finds annotation in instance var (assignment) finds annotation in instance var (assignment) + errors if using invalid annotation on fun errors if using invalid annotation on fun + finds annotation in generic parent (#7885) finds annotation in generic parent (#7885) + finds annotation on method arg finds annotation on method arg + finds annotation in enum finds annotation in enum + can't find annotation in module can't find annotation in module + can't find annotation in instance var, when other annotations are present can't find annotation in instance var, when other annotations are present + overrides annotation value in type overrides annotation value in type + overrides annotation in instance var overrides annotation in instance var + finds annotation on method splat arg finds annotation on method splat arg + errors if annotation doesn't exist errors if annotation doesn't exist + finds annotation in module finds annotation in module + finds annotation in instance var (declaration) finds annotation in instance var (declaration) + doesn't carry link annotation from lib to fun doesn't carry link annotation from lib to fun + errors if using annotation other than ThreadLocal for class vars errors if using annotation other than ThreadLocal for class vars + finds annotation in instance var (declaration, generic) finds annotation in instance var (declaration, generic) + can't find annotation on def can't find annotation on def + uses annotation value, keyword uses annotation value, keyword + can't find annotation in module, when other annotations are present can't find annotation in module, when other annotations are present + adds annotation on def adds annotation on def + finds annotation in struct finds annotation in struct + finds annotation in class finds annotation in class + finds annotation on method double splat arg finds annotation on method double splat arg + can't find annotation in instance var can't find annotation in instance var + can't find annotation on def, when other annotations are present can't find annotation on def, when other annotations are present + finds annotation on an restricted method block arg finds annotation on an restricted method block arg + errors if annotation doesn't point to an annotation type errors if annotation doesn't point to an annotation type + finds annotation in lib finds annotation in lib + uses annotation value, positional uses annotation value, positional + arguments + returns a correctly with named and positional args returns a correctly with named and positional args + #named_args + returns an empty NamedTupleLiteral if there are none defined returns an empty NamedTupleLiteral if there are none defined + returns a NamedTupleLiteral if there are named arguments defined returns a NamedTupleLiteral if there are named arguments defined + #args + returns an empty TupleLiteral if there are none defined returns an empty TupleLiteral if there are none defined + returns a TupleLiteral if there are positional arguments defined returns a TupleLiteral if there are positional arguments defined + #annotations + all types + finds annotations on a enum finds annotations on a enum + finds annotations on a class finds annotations on a class + finds annotations on a lib finds annotations on a lib + find annotations on method parameters find annotations on method parameters + finds annotations on a module finds annotations on a module + finds annotations on a struct finds annotations on a struct + finds annotations in instance var (declaration) finds annotations in instance var (declaration) + adds annotations on def adds annotations on def + finds annotations in instance var (declaration, generic) finds annotations in instance var (declaration, generic) + returns an empty array if there are none defined returns an empty array if there are none defined + finds annotations in generic parent (#7885) finds annotations in generic parent (#7885) + of a specific type + returns an empty array if there are none defined returns an empty array if there are none defined + uses annotations value, positional uses annotations value, positional + finds annotations in struct finds annotations in struct + adds annotations on def adds annotations on def + collects annotations values in type collects annotations values in type + can't find annotations on def can't find annotations on def + can't find annotations in instance var can't find annotations in instance var + uses annotations value, keyword uses annotations value, keyword + find annotations on method parameters find annotations on method parameters + finds annotations in instance var (declaration) finds annotations in instance var (declaration) + can't find annotations on def, when other annotations are present can't find annotations on def, when other annotations are present + finds annotations in generic parent (#7885) finds annotations in generic parent (#7885) + finds annotations in class finds annotations in class + finds annotations in instance var (declaration, generic) finds annotations in instance var (declaration, generic) + finds annotations in lib finds annotations in lib + finds annotations in enum finds annotations in enum + overrides annotations value in type overrides annotations value in type + finds annotations on a module finds annotations on a module + can't find annotations in instance var, when other annotations are present can't find annotations in instance var, when other annotations are present + errors if wanting to add type inside annotation (1) (#8614) errors if wanting to add type inside annotation (1) (#8614) + declares annotation declares annotation + doesn't bleed annotation from class into class variable (#8314) doesn't bleed annotation from class into class variable (#8314) + errors when annotate instance variable in subclass errors when annotate instance variable in subclass +Codegen: responds_to? + codegens responds_to? with union gives true codegens responds_to? with union gives true + works with generic virtual superclass (2) works with generic virtual superclass (2) + works with generic virtual superclass (1) works with generic virtual superclass (1) + works with virtual type works with virtual type + doesn't error if result is discarded (#14113) doesn't error if result is discarded (#14113) + codegens responds_to? with generic class (1) codegens responds_to? with generic class (1) + works with virtual class type (1) (#1926) works with virtual class type (1) (#1926) + works with virtual class type (2) (#1926) works with virtual class type (2) (#1926) + works with generic virtual module (2) (#8334) works with generic virtual module (2) (#8334) + codegens responds_to? true for simple type codegens responds_to? true for simple type + codegens responds_to? with generic class (2) codegens responds_to? with generic class (2) + codegens responds_to? with nilable gives false because other type 2 codegens responds_to? with nilable gives false because other type 2 + works with two virtual types works with two virtual types + works with generic virtual module (1) works with generic virtual module (1) + codegens responds_to? with nilable gives false because other type 1 codegens responds_to? with nilable gives false because other type 1 + works with module works with module + codegens responds_to? with nilable gives true codegens responds_to? with nilable gives true + does for generic instance type metaclass (#4353) does for generic instance type metaclass (#4353) + codegens responds_to? with union gives false codegens responds_to? with union gives false + codegens responds_to? false for simple type codegens responds_to? false for simple type +Semantic: closure + correctly captures type of closured block arg correctly captures type of closured block arg + doesn't crash for non-existing variable (#3789) doesn't crash for non-existing variable (#3789) + doesn't mark var as closured if only used in two block doesn't mark var as closured if only used in two block + marks variable as closured inside block in fun marks variable as closured inside block in fun + marks method as self closured if instance var is written marks method as self closured if instance var is written + marks outer fun inside a block as closured marks outer fun inside a block as closured + doesn't mark self var as closured, but marks method as self closured doesn't mark self var as closured, but marks method as self closured + marks outer fun as closured when using self marks outer fun as closured when using self + lookups return type in correct scope lookups return type in correct scope + says can't send closure to C with captured block says can't send closure to C with captured block + transforms block to proc literal with free var transforms block to proc literal with free var + gives error when doing yield inside proc literal gives error when doing yield inside proc literal + errors if giving more block args when transforming block to proc literal errors if giving more block args when transforming block to proc literal + errors if sending closured proc pointer to C (3) errors if sending closured proc pointer to C (3) + marks method as self closured if explicit self call is made marks method as self closured if explicit self call is made + marks method as self closured if used inside a block marks method as self closured if used inside a block + marks variable as closured in program on assign marks variable as closured in program on assign + errors when transforming block to proc literal if type mismatch errors when transforming block to proc literal if type mismatch + errors if sending closured proc pointer to C (1.2) errors if sending closured proc pointer to C (1.2) + does assign all types to metavar if closured but only assigned to once in a loop through block does assign all types to metavar if closured but only assigned to once in a loop through block + can use fun typedef as block type can use fun typedef as block type + marks variable as closured in def marks variable as closured in def + transforms block to proc literal without parameters transforms block to proc literal without parameters + says can't send closure to C with new notation says can't send closure to C with new notation + errors if sending closured proc pointer to C (1) errors if sending closured proc pointer to C (1) + errors if sending closured proc pointer to C (2) errors if sending closured proc pointer to C (2) + unifies types of closured var (1) unifies types of closured var (1) + doesn't assign all types to metavar if closured but declared inside block and re-assigned inside the same context before the closure doesn't assign all types to metavar if closured but declared inside block and re-assigned inside the same context before the closure + marks method as self closured if implicit self call is made marks method as self closured if implicit self call is made + correctly detects previous var as closured (#5609) correctly detects previous var as closured (#5609) + doesn't closure typeof instance var (#9479) doesn't closure typeof instance var (#9479) + marks method as self closured if instance var is read marks method as self closured if instance var is read + does assign all types to metavar if closured but only assigned to once in a loop does assign all types to metavar if closured but only assigned to once in a loop + errors if forwarding block param doesn't match input type size errors if forwarding block param doesn't match input type size + does assign all types to metavar if closured but only assigned to once in a loop through captured block does assign all types to metavar if closured but only assigned to once in a loop through captured block + marks variable as closured in program marks variable as closured in program + errors if forwarding block param doesn't match input type errors if forwarding block param doesn't match input type + doesn't closure typeof local var doesn't closure typeof local var + transforms block to proc literal transforms block to proc literal + doesn't assign all types to metavar if closured but declared inside block and never re-assigned doesn't assign all types to metavar if closured but declared inside block and never re-assigned + gives error when doing yield inside proc literal gives error when doing yield inside proc literal + doesn't assign all types to metavar if closured but only assigned to once doesn't assign all types to metavar if closured but only assigned to once + marks variable as closured in block marks variable as closured in block + allows passing block as proc literal to new and to initialize allows passing block as proc literal to new and to initialize + unifies types of closured var (2) unifies types of closured var (2) + allows giving less block args when transforming block to proc literal allows giving less block args when transforming block to proc literal + is considered as closure if assigned once but comes from a method arg is considered as closure if assigned once but comes from a method arg + passes #227 passes #227 + transforms block to proc literal with void type transforms block to proc literal with void type + errors if sending closured proc literal to C errors if sending closured proc literal to C + doesn't mark var as closured if only used in block doesn't mark var as closured if only used in block + considers var as closure-readonly if it was assigned multiple times before it was closured considers var as closure-readonly if it was assigned multiple times before it was closured +Code gen: primitives + codegens f32 codegens f32 + defined method that calls primitive (bug) defined method that calls primitive (bug) + va_arg + uses llvm's va_arg instruction uses llvm's va_arg instruction + works with C code works with C code works with C code works with C code works with C code works with C code works with C code works with C code works with C code works with C code + codegens crystal_type_id for class codegens crystal_type_id for class + codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 + gets crystal class instance type id gets crystal class instance type id + codegens int codegens int + can invoke binary on primitive typedef (#614) can invoke binary on primitive typedef (#614) + codegens string codegens string + allows @[Primitive] on fun declarations allows @[Primitive] on fun declarations + doesn't optimize away call whose obj is not passed as self (#2226) doesn't optimize away call whose obj is not passed as self (#2226) + sums two numbers out of an [] of Number sums two numbers out of an [] of Number + codegens pointer of int codegens pointer of int + codegens bool codegens bool + codegens char codegens char + allows redefining a primitive method allows redefining a primitive method + codegens f64 codegens f64 + codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 + codegens char ord codegens char ord + can invoke cast on primitive typedef (#614) can invoke cast on primitive typedef (#614) + codegens __LINE__ codegens __LINE__ + codegens crystal_type_id with union type codegens crystal_type_id with union type + codegens long codegens long + doesn't treat `(1 == 1) == true` as `1 == 1 == true` (#328) doesn't treat `(1 == 1) == true` as `1 == 1 == true` (#328) + allows @[Primitive] on method that has body allows @[Primitive] on method that has body + uses built-in llvm function that returns a tuple uses built-in llvm function that returns a tuple + passes issue #328 passes issue #328 + arithmetic primitives + codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 + codegens 16.unsafe_shr 2 codegens 16.unsafe_shr 2 + codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 + codegens 1.to_f! codegens 1.to_f! + codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f + codegens 8.unsafe_div 3 codegens 8.unsafe_div 3 + codegens 1 &- 2 codegens 1 &- 2 + codegens 2 &* 3 codegens 2 &* 3 + codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 + codegens 16.unsafe_shl 2 codegens 16.unsafe_shl 2 + codegens 1.to_i16! codegens 1.to_i16! + codegens 8.unsafe_mod 3 codegens 8.unsafe_mod 3 + codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 + skips bounds checking when to_i produces same type skips bounds checking when to_i produces same type + codegens 1 &+ 2 codegens 1 &+ 2 + atomicrmw + codegens atomicrmw with enums codegens atomicrmw with enums + codegens atomicrmw with symbols codegens atomicrmw with symbols + codegens atomicrmw with enums codegens atomicrmw with enums +Semantic: cast + doesn't eagerly try to check cast type (#12268) doesn't eagerly try to check cast type (#12268) + casts to same type is ok casts to same type is ok + doesn't crash with typeof no-type (#7441) doesn't crash with typeof no-type (#7441) + doesn't cast to unbound generic type (as?) (#5927) doesn't cast to unbound generic type (as?) (#5927) + casts to generic virtual type casts to generic virtual type + disallows casting int to pointer disallows casting int to pointer + casts from union to compatible union casts from union to compatible union + can cast to metaclass (bug) can cast to metaclass (bug) + casts to target type even if can't infer casted value type (obsolete) casts to target type even if can't infer casted value type (obsolete) + doesn't cast to unbound generic type (as) (#5927) doesn't cast to unbound generic type (as) (#5927) + casts to module casts to module + disallows casting to Reference disallows casting to Reference + casts pointer of one type to another type casts pointer of one type to another type + can cast from Void* to virtual type (#3014) can cast from Void* to virtual type (#3014) + disallows casting to Class disallows casting to Class + considers else to be unreachable (#9658) considers else to be unreachable (#9658) + casts from union to incompatible union gives error casts from union to incompatible union gives error + errors if casting nil to Object inside typeof (#2403) errors if casting nil to Object inside typeof (#2403) + can cast to metaclass (2) (#11121) can cast to metaclass (2) (#11121) + casts pointer to another type casts pointer to another type + doesn't cast to virtual primitive (bug) doesn't cast to virtual primitive (bug) + doesn't allow upcast of generic type var (#996) doesn't allow upcast of generic type var (#996) + allows casting reference union to void pointer allows casting reference union to void pointer + allows casting object to void pointer allows casting object to void pointer + casts to compatible type and use it casts to compatible type and use it + casts to base class making it virtual (2) casts to base class making it virtual (2) + errors on cast inside a call that can't be instantiated errors on cast inside a call that can't be instantiated + doesn't error if casting to a generic type doesn't error if casting to a generic type + disallows casting fun to pointer disallows casting fun to pointer + casts from pointer to generic class gives error casts from pointer to generic class gives error + disallows casting pointer to fun disallows casting pointer to fun + casts to base class making it virtual (1) casts to base class making it virtual (1) + allows casting NoReturn to any type (#2132) allows casting NoReturn to any type (#2132) + should error if can't cast even if not instantiated should error if can't cast even if not instantiated + casts uninstantiated generic class to itself (#10882) casts uninstantiated generic class to itself (#10882) + disallows casting to Object (#815) disallows casting to Object (#815) + casts to incompatible type gives error casts to incompatible type gives error + casts to bigger union casts to bigger union Crystal::Doc::ProjectInfo + .find_git_version .find_git_version + .find_source_url_pattern .find_source_url_pattern .read_shard_properties - duplicate properties uses first one duplicate properties uses first one - strip quotes strip quotes indented properties indented properties - only name only name strip whitespace strip whitespace - empty properties empty properties ignores comments ignores comments + duplicate properties uses first one duplicate properties uses first one no shard.yml no shard.yml - without name and version properties without name and version properties + strip quotes strip quotes + empty properties empty properties name and version name and version - #source_url - builds url builds url - builds url builds url - fails if pattern is missing fails if pattern is missing - returns nil for empty pattern returns nil for empty pattern - fails if refname is missing fails if refname is missing - fails if pattern is missing fails if pattern is missing - .find_git_version .find_git_version - .find_source_url_pattern .find_source_url_pattern + only name only name + without name and version properties without name and version properties + .git_remote + no git workdir no git workdir + no origin remote no origin remote + origin plus other origin plus other + simple origin simple origin + no remote no remote #fill_with_defaults + no shard.yml, but git tagged version no shard.yml, but git tagged version empty folder empty folder with shard.yml git tagged version git tagged version - git missing git missing - git non-tagged commit git non-tagged commit - git untracked file doesn't prevent detection git untracked file doesn't prevent detection git with remote git with remote - not in a git folder not in a git folder git but no commit git but no commit + git untracked file doesn't prevent detection git untracked file doesn't prevent detection + git missing git missing git non-tagged commit dirty git non-tagged commit dirty git tagged version dirty git tagged version dirty - no shard.yml, but git tagged version no shard.yml, but git tagged version - .git_remote - no git workdir no git workdir - simple origin simple origin - no remote no remote - origin plus other origin plus other - no origin remote no origin remote + not in a git folder not in a git folder + git non-tagged commit git non-tagged commit + #source_url + fails if pattern is missing fails if pattern is missing + builds url builds url + fails if pattern is missing fails if pattern is missing + returns nil for empty pattern returns nil for empty pattern + fails if refname is missing fails if refname is missing + builds url builds url +Normalize: until + normalizes until normalizes until +Semantic: restrictions augmenter + augments Bool augments Bool + augments relative public type augments relative public type + augments Int32.class augments Int32.class + augments Char augments Char + augments Tuple(Int32, Char) augments Tuple(Int32, Char) + doesn't augment if the no_restrictions_augmenter flag is present doesn't augment if the no_restrictions_augmenter flag is present + augments Char | Int32 | String augments Char | Int32 | String + augments virtual type augments virtual type + augments Int32 augments Int32 + augments relative private type in same namespace augments relative private type in same namespace + doesn't augment if assigned inside if doesn't augment if assigned inside if + augments Char | Int32 | String augments Char | Int32 | String + augments Enumerable(Int32).class augments Enumerable(Int32).class + augments Nil augments Nil + augments Float32 augments Float32 + augments Proc(Int32, Char) augments Proc(Int32, Char) + augments for class var augments for class var + augments Array(String) augments Array(String) + augments virtual metaclass type augments virtual metaclass type + augments for Union(*T) (#12435) augments for Union(*T) (#12435) + augments typedef augments typedef + augments StaticArray(Int32, 8) augments StaticArray(Int32, 8) + augments NoReturn augments NoReturn + augments String augments String + augments recursive alias type (#12134) augments recursive alias type (#12134) + doesn't augment if assigned inside while doesn't augment if assigned inside while + augments Pointer(Void) augments Pointer(Void) + augments generic uninstantiated type augments generic uninstantiated type + augments Array(Int32).class augments Array(Int32).class + augments NamedTuple(a: Int32, b: Char) augments NamedTuple(a: Int32, b: Char) + doesn't crash on macro that yields and defines class (#12142) doesn't crash on macro that yields and defines class (#12142) + doesn't augment if assigned inside block doesn't augment if assigned inside block + augments Proc(Int32, Nil) augments Proc(Int32, Nil) + augments Symbol augments Symbol + augments relative private type augments relative private type + augments type splat augments type splat +Codegen: while + doesn't crash on #2767 (2) doesn't crash on #2767 (2) + codegens while with declared var 3 codegens while with declared var 3 + codegens while with declared var 1 codegens while with declared var 1 + codegens while with declared var 2 codegens while with declared var 2 + endless break with value endless break with value + doesn't crash on #2767 (3) doesn't crash on #2767 (3) + codegens while with false codegens while with false + skip block with next skip block with next + break without value break without value + codegens def with while codegens def with while + conditional break without value conditional break without value + endless conditional break with value endless conditional break with value + doesn't crash on #2767 doesn't crash on #2767 + break with value, condition fails break with value, condition fails + doesn't crash on #2767 (4) doesn't crash on #2767 (4) + conditional break with value conditional break with value + codegens while with non-false condition codegens while with non-false condition + break with value break with value + doesn't crash on a = NoReturn doesn't crash on a = NoReturn + doesn't crash on while true begin break rescue (#7786) doesn't crash on while true begin break rescue (#7786) + codegens endless while codegens endless while +Crystal::Config + .linux_runtime_libc .linux_runtime_libc + .host_target .host_target +Semantic: primitives + types char ord types char ord + can invoke cast on primitive typedef (#614) can invoke cast on primitive typedef (#614) + Reference.pre_initialize + types with virtual reference type types with virtual reference type + types with reference type types with reference type + errors on uninstantiated generic type errors on uninstantiated generic type + errors on abstract type errors on abstract type + types a float32 types a float32 + types 1 + 2 types 1 + 2 + types a float64 types a float64 + types pointer of int types pointer of int + types a char types a char + types va_arg primitive types va_arg primitive + errors if @[Primitive] has no args errors if @[Primitive] has no args + types nop types nop + types a symbol types a symbol + types a bool types a bool + extends from Number and doesn't find to_i method extends from Number and doesn't find to_i method + types an expression types an expression + Slice.literal + with element type + types empty literal types empty literal + errors if element type is not primitive int or float errors if element type is not primitive int or float + types primitive float literal types primitive float literal + errors if element is out of range errors if element is out of range + errors if element is not number literal errors if element is not number literal + types primitive int literal types primitive int literal + types nil types nil + correctly types first hash from type vars (bug) correctly types first hash from type vars (bug) + computes correct hash value type if it's a function literal (#320) computes correct hash value type if it's a function literal (#320) + can invoke binary on primitive typedef (#614) can invoke binary on primitive typedef (#614) + types a string types a string + errors if using instance variable inside primitive type errors if using instance variable inside primitive type + types a uint128 types a uint128 + types an int32 types an int32 + types @[Primitive] method types @[Primitive] method + errors when comparing void (#225) errors when comparing void (#225) + can invoke binary on primitive typedef (2) (#614) can invoke binary on primitive typedef (2) (#614) + extends from Number and doesn't find + method extends from Number and doesn't find + method + looks up return type in correct scope (#13652) looks up return type in correct scope (#13652) + types a int128 types a int128 + types a int64 types a int64 + errors if @[Primitive] has non-symbol arg errors if @[Primitive] has non-symbol arg + extends from Number and doesn't find >= method extends from Number and doesn't find >= method + allows @[Primitive] on method that has body allows @[Primitive] on method that has body +Crystal::Repl + can return static and runtime type information for + VirtualType VirtualType + MixedUnionType MixedUnionType + Non Union Non Union + UnionType UnionType + can parse and evaluate snippets can parse and evaluate snippets +Code gen: hooks + does added method macro does added method macro + does finished does finished + fixes empty types in hooks (#3946) fixes empty types in hooks (#3946) + does inherited macro recursively does inherited macro recursively + does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body + does extended macro does extended macro + does included macro does included macro + does inherited macro does inherited macro +Codegen: super + codegens super that calls subclass method 6 codegens super that calls subclass method 6 + codegens super without arguments and instance variable codegens super without arguments and instance variable + does super in virtual type including module does super in virtual type including module + build super on generic class (bug) build super on generic class (bug) + codegens super that calls subclass method 4 codegens super that calls subclass method 4 + doesn't invoke super twice in inherited generic types (#942) doesn't invoke super twice in inherited generic types (#942) + codegens super that calls subclass method 3 codegens super that calls subclass method 3 + calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) + codegens super inside closure forwarding args codegens super inside closure forwarding args + codegens super inside closure codegens super inside closure + calls super from virtual metaclass type (#2841) calls super from virtual metaclass type (#2841) + codegens super without arguments codegens super without arguments + codegens super that calls subclass method 5 codegens super that calls subclass method 5 + calls super on an object (#10004) calls super on an object (#10004) + calls super in generic module method calls super in generic module method + codegens super that calls subclass method 2 codegens super that calls subclass method 2 + calls super in module method (#556) calls super in module method (#556) + codegens super that calls subclass method codegens super that calls subclass method + codegens super without arguments but parent has arguments codegens super without arguments but parent has arguments + calls super with dispatch (#2318) calls super with dispatch (#2318) +Semantic: new + errors if using self call in default argument (2) errors if using self call in default argument (2) + evaluates initialize default value at the instance scope (2) (#731) evaluates initialize default value at the instance scope (2) (#731) + doesn't have default new for inherited class from generic type doesn't have default new for inherited class from generic type + evaluates initialize default value at the instance scope (4) (#731) evaluates initialize default value at the instance scope (4) (#731) + inherits initialize and new methods if doesn't define new (#3238) inherits initialize and new methods if doesn't define new (#3238) + errors if using self call in default argument (1) errors if using self call in default argument (1) + evaluates initialize default value at the instance scope (6) (#731) evaluates initialize default value at the instance scope (6) (#731) + errors if using self call in default argument (3) errors if using self call in default argument (3) + evaluates initialize default value at the instance scope (5) (#731) evaluates initialize default value at the instance scope (5) (#731) + uses correct receiver for `initialize` in namespaced generic classes (#4086) uses correct receiver for `initialize` in namespaced generic classes (#4086) + evaluates initialize default value at the instance scope (1) (#731) evaluates initialize default value at the instance scope (1) (#731) + evaluates initialize default value at the instance scope (3) (#731) evaluates initialize default value at the instance scope (3) (#731) + doesn't incorrectly redefines new for generic class doesn't incorrectly redefines new for generic class +Code gen: new + finds new in superclass if no initialize is defined (1) finds new in superclass if no initialize is defined (1) + evaluates initialize default value at the instance scope (3) (#731) evaluates initialize default value at the instance scope (3) (#731) + codegens instance method with new codegens instance method with new + evaluates initialize default value at the instance scope (4) (#731) evaluates initialize default value at the instance scope (4) (#731) + evaluates initialize default value at the instance scope (2) (#731) evaluates initialize default value at the instance scope (2) (#731) + finds super in deep hierarchy finds super in deep hierarchy + defines new for module defines new for module + can create Reference can create Reference + inherits initialize for generic type inherits initialize for generic type + overloads new and initialize, 2 (#2489) overloads new and initialize, 2 (#2489) + finds new in superclass for Enum finds new in superclass for Enum + codegens instance method with new and instance var codegens instance method with new and instance var + inherits initialize inherits initialize + overloads new and initialize, 3 (#2489) overloads new and initialize, 3 (#2489) + can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new + codegens instance method with allocate codegens instance method with allocate + overloads new and initialize, 1 (#2489) overloads new and initialize, 1 (#2489) + evaluates initialize default value at the instance scope (1) (#731) evaluates initialize default value at the instance scope (1) (#731) + finds new in superclass if no initialize is defined (2) finds new in superclass if no initialize is defined (2) +Semantic: multi assign + without strict_multi_assign + errors if assigning non-Indexable to splat (#11414) errors if assigning non-Indexable to splat (#11414) + doesn't error if assigning non-Indexable (#11414) doesn't error if assigning non-Indexable (#11414) + doesn't error if assigning tuple to fewer targets doesn't error if assigning tuple to fewer targets + strict_multi_assign + errors if assigning non-Indexable (#11414) errors if assigning non-Indexable (#11414) + errors if assigning tuple to more targets errors if assigning tuple to more targets + doesn't error if some type in union matches target count doesn't error if some type in union matches target count + errors if assigning tuple to fewer targets errors if assigning tuple to fewer targets + errors if assigning non-Indexable to splat (#11414) errors if assigning non-Indexable to splat (#11414) + doesn't error if some type in union has no constant size doesn't error if some type in union has no constant size + errors if assigning union of tuples to fewer targets errors if assigning union of tuples to fewer targets + can pass splat variable at top-level to macros (#11596) can pass splat variable at top-level to macros (#11596) +Semantic: while + doesn't fail on new variables inside typeof condition doesn't fail on new variables inside typeof condition + uses var type inside while if endless loop uses var type inside while if endless loop + doesn't type var as nilable after break inside rescue doesn't type var as nilable after break inside rescue + finds while cond assign target in Not (#10345) finds while cond assign target in Not (#10345) + restricts type after while (#4242) restricts type after while (#4242) + types endless while with break without value types endless while with break without value + doesn't use type at end of endless while if variable is reassigned (2) doesn't use type at end of endless while if variable is reassigned (2) + types endless while with multiple breaks with value types endless while with multiple breaks with value + doesn't restrict type after while if there's a break (#4242) doesn't restrict type after while if there's a break (#4242) + rebinds condition variable after while body (#6158) rebinds condition variable after while body (#6158) + types while with && (#1425) types while with && (#1425) + marks variable as nil if breaking before assigning to it in an endless loop (2) marks variable as nil if breaking before assigning to it in an endless loop (2) + reports break cannot be used outside a while reports break cannot be used outside a while + types while with assignment types while with assignment + restricts type after `while` with `not` and `and` (#4242) restricts type after `while` with `not` and `and` (#4242) + types while with assignment and && types while with assignment and && + types endless while with break with value types endless while with break with value + types while (true) as NoReturn types while (true) as NoReturn + doesn't fail on Expressions condition (2) doesn't fail on Expressions condition (2) + types variable as nilable if raise before assign types variable as nilable if raise before assign + uses type at end of endless while if variable is reassigned, but not before first break (2) uses type at end of endless while if variable is reassigned, but not before first break (2) + restricts type after while with not (#4242) restricts type after while with not (#4242) + types while with multiple breaks with value types while with multiple breaks with value + finds all while cond assign targets in expressions (6) finds all while cond assign targets in expressions (6) + doesn't use type at end of endless while if variable is reassigned doesn't use type at end of endless while if variable is reassigned + types while with break with value types while with break with value + finds all while cond assign targets in expressions (5) finds all while cond assign targets in expressions (5) + types while with assignment and call types while with assignment and call + types while with break without value types while with break without value + doesn't fail on Expressions condition (1) doesn't fail on Expressions condition (1) + doesn't fail on nested conditionals inside typeof condition doesn't fail on nested conditionals inside typeof condition + finds all while cond assign targets in expressions (4) finds all while cond assign targets in expressions (4) + uses type at end of endless while if variable is reassigned, but not before first break uses type at end of endless while if variable is reassigned, but not before first break + finds all while cond assign targets in expressions (#10350) finds all while cond assign targets in expressions (#10350) + doesn't modify var's type before while doesn't modify var's type before while + doesn't use type at end of endless while if variable is reassigned (3) doesn't use type at end of endless while if variable is reassigned (3) + types while true as NoReturn types while true as NoReturn + uses var type inside while if endless loop (2) uses var type inside while if endless loop (2) + types while types while + reports next cannot be used outside a while reports next cannot be used outside a while + finds all while cond assign targets in expressions (3) finds all while cond assign targets in expressions (3) + marks variable as nil if breaking before assigning to it in an endless loop marks variable as nil if breaking before assigning to it in an endless loop + types while ((true)) as NoReturn types while ((true)) as NoReturn + finds all while cond assign targets in expressions (2) finds all while cond assign targets in expressions (2) +Codegen: thread local + compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer + works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables + works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread +Semantic: struct + types struct getter with keyword name types struct getter with keyword name + errors if includes and field already exists, the other way around errors if includes and field already exists, the other way around + errors if invoking to_unsafe and got error in that call errors if invoking to_unsafe and got error in that call + errors if already defined with another type (2) errors if already defined with another type (2) + errors on struct setter if different type via new errors on struct setter if different type via new + includes another struct includes another struct + supports macro if inside struct supports macro if inside struct + allows inline forward declaration allows inline forward declaration + errors if already defined errors if already defined + automatically converts numeric type in struct field assignment automatically converts numeric type in struct field assignment + types struct types struct + errors if setting closure errors if setting closure + types Struct#new types Struct#new + errors on struct if no field errors on struct if no field + errors if using void in struct field type errors if using void in struct field type + errors on struct setter if different type errors on struct setter if different type + errors if already defined with another type errors if already defined with another type + marks as packed marks as packed + errors if includes and field already exists errors if includes and field already exists + errors if using void via typedef in struct field type errors if using void via typedef in struct field type + errors if includes non-cstruct type errors if includes non-cstruct type + can access instance var from the outside (#1092) can access instance var from the outside (#1092) + types struct getter multiple levels via new types struct getter multiple levels via new + types struct getter on pointer type types struct getter on pointer type + errors if invoking to_i32! and got wrong type errors if invoking to_i32! and got wrong type + errors if invoking to_unsafe and got different type errors if invoking to_unsafe and got different type + errors on empty c struct (#633) errors on empty c struct (#633) + types struct setter types struct setter + errors if includes unknown type errors if includes unknown type + types struct getter to struct types struct getter to struct + errors if invoking to_i32! and got error in that call errors if invoking to_i32! and got error in that call + types struct getter types struct getter +Crystal::Repl::Interpreter + extern + discards primitive struct_or_union_set and get (struct) discards primitive struct_or_union_set and get (struct) + discards primitive struct_or_union_set because it's a copy discards primitive struct_or_union_set because it's a copy + sets struct field through pointer sets struct field through pointer + interprets primitive struct_or_union_set and get (union) interprets primitive struct_or_union_set and get (union) + interprets primitive struct_or_union_set and get (struct) interprets primitive struct_or_union_set and get (struct) + sets extern struct proc field sets extern struct proc field + does automatic C cast does automatic C cast +Semantic: automatic cast + casts integer variable to larger type (Int64 to Int128) (#9565) casts integer variable to larger type (Int64 to Int128) (#9565) + says ambiguous call for integer var to larger type (#9565) says ambiguous call for integer var to larger type (#9565) + casts integer variable to larger type (#9565) casts integer variable to larger type (#9565) + casts Int32 -> Int64 in arg restriction casts Int32 -> Int64 in arg restriction + doesn't autocast number on union (#8655) doesn't autocast number on union (#8655) + casts Int32 to Int64 in ivar assignment casts Int32 to Int64 in ivar assignment + doesn't say 'ambiguous call' when there's an exact match for symbol (#6601) doesn't say 'ambiguous call' when there's an exact match for symbol (#6601) + casts literal integer in private top-level method (#7016) casts literal integer in private top-level method (#7016) + casts literal integer (Int32 -> Float32) casts literal integer (Int32 -> Float32) + casts literal integer (Int32 -> no restriction) casts literal integer (Int32 -> no restriction) + casts Symbol to Enum in ivar type declaration casts Symbol to Enum in ivar type declaration + casts literal integer through alias with union casts literal integer through alias with union + casts literal integer (Int64 -> Int32, ok) casts literal integer (Int64 -> Int32, ok) + can autocast to union in default value can autocast to union in default value + casts Symbol to Enum in ivar assignment casts Symbol to Enum in ivar assignment + can match multiple times with the same argument type (#7578) can match multiple times with the same argument type (#7578) + says ambiguous call for integer says ambiguous call for integer + casts Symbol to Enum in cvar type declaration casts Symbol to Enum in cvar type declaration + autocasts nested type from non-nested type (#10315) autocasts nested type from non-nested type (#10315) + errors if symbol name doesn't match enum member errors if symbol name doesn't match enum member + doesn't do multidispatch if an overload matches exactly (#8217) doesn't do multidispatch if an overload matches exactly (#8217) + can autocast to union in default value (multiple enums) can autocast to union in default value (multiple enums) + casts Int32 to Int64 in lvar assignment casts Int32 to Int64 in lvar assignment + casts symbol literal to enum casts symbol literal to enum + casts literal float (Float64 -> Float32) casts literal float (Float64 -> Float32) + casts literal integer through alias with union casts literal integer through alias with union + can use automatic cast with `with ... yield` (#7736) can use automatic cast with `with ... yield` (#7736) + says ambiguous call for integer (2) says ambiguous call for integer (2) + doesn't cast integer variable to larger type (not #9565) doesn't cast integer variable to larger type (not #9565) + doesn't do multidispatch if an overload matches exactly (#8217) doesn't do multidispatch if an overload matches exactly (#8217) + casts integer expression to larger type (#9565) casts integer expression to larger type (#9565) + can autocast to union in default value (symbol and int) can autocast to union in default value (symbol and int) + says ambiguous call for integer on alias (#6620) says ambiguous call for integer on alias (#6620) + can't cast integer to another type when it doesn't fit (#9565) can't cast integer to another type when it doesn't fit (#9565) + autocasts integer variable to float type (#9565) autocasts integer variable to float type (#9565) + doesn't say 'ambiguous call' when there's an exact match for integer (#6601) doesn't say 'ambiguous call' when there's an exact match for integer (#6601) + can autocast to alias in default value can autocast to alias in default value + says ambiguous call for integer var to union type (#9565) says ambiguous call for integer var to union type (#9565) + casts literal integer (Int64 -> Int32, too big) casts literal integer (Int64 -> Int32, too big) + autocasts float32 variable to float64 type (#9565) autocasts float32 variable to float64 type (#9565) + casts literal float (Float32 -> Float64) casts literal float (Float32 -> Float64) + matches correct overload matches correct overload + autocasts first argument and second matches without autocast autocasts first argument and second matches without autocast + casts literal integer (Int32 -> Float64) casts literal integer (Int32 -> Float64) + casts Int32 to Int64 in cvar type declaration casts Int32 to Int64 in cvar type declaration + casts literal integer (Int32 -> Int64) casts literal integer (Int32 -> Int64) + casts Int32 to Int64 in ivar type declaration casts Int32 to Int64 in ivar type declaration + casts Int32 to Int64 in ivar type declaration in generic casts Int32 to Int64 in ivar type declaration in generic + says ambiguous call for symbol says ambiguous call for symbol + says ambiguous call on union (#8655) says ambiguous call on union (#8655) + casts Int32 to Int64 in cvar assignment casts Int32 to Int64 in cvar assignment + errors when autocast default value doesn't match enum member errors when autocast default value doesn't match enum member +Block inference + errors if using ( -> Object) as block return type (#2358) errors if using ( -> Object) as block return type (#2358) + ignores block parameter if not used ignores block parameter if not used + matches block arg return type matches block arg return type + infer type of block parameter infer type of block parameter + errors if returns from captured block errors if returns from captured block + respects block arg restriction when block has a splat parameter (#6473) respects block arg restriction when block has a splat parameter (#6473) + does next from captured block does next from captured block + doesn't crash on #2531 doesn't crash on #2531 + reports error if yields a type that's not that one in the block specification reports error if yields a type that's not that one in the block specification + reports error if yields a type that later changes and that's not that one in the block specification reports error if yields a type that later changes and that's not that one in the block specification + infer type of empty block body infer type of empty block body + reports error on method instantiate (#4543) reports error on method instantiate (#4543) + allows underscore in block return type even if the return type can't be computed allows underscore in block return type even if the return type can't be computed + preserves type filters in block preserves type filters in block + errors if declares class inside captured block errors if declares class inside captured block + uses free var in return type with tuple type uses free var in return type with tuple type + reports mismatch with generic argument type in input type reports mismatch with generic argument type in input type + errors if declares class inside block errors if declares class inside block + infers type of block before call infers type of block before call + errors if declares fun inside block errors if declares fun inside block + errors on recursive yield errors on recursive yield + maps block of union types to union types maps block of union types to union types + checks block type with virtual type checks block type with virtual type + errors when using local variable with block parameter name errors when using local variable with block parameter name + reports error if block type doesn't match reports error if block type doesn't match + auto-unpacks tuple, less than max auto-unpacks tuple, less than max + returns from proc literal returns from proc literal + errors if proc is not instantiated errors if proc is not instantiated + uses splat in block parameter uses splat in block parameter + infer type of yield infer type of yield + error with self output type doesn't match error with self output type doesn't match + binds to proc, not only to its body (#1796) binds to proc, not only to its body (#1796) + unpacks block argument unpacks block argument + auto-unpacks tuple, captured block with multiple statements auto-unpacks tuple, captured block with multiple statements + infer type of block body infer type of block body + error with self input type doesn't match error with self input type doesn't match + ignores void return type (4) ignores void return type (4) + auto-unpacks tuple auto-unpacks tuple + errors if alias is not a fun type errors if alias is not a fun type + auto-unpacks with block arg type auto-unpacks with block arg type + yields splat and non splat yields splat and non splat + errors if doing next in proc literal errors if doing next in proc literal + errors if declares lib inside block errors if declares lib inside block + reports mismatch with generic argument type in output type reports mismatch with generic argument type in output type + sets captured block type to that of restriction with alias sets captured block type to that of restriction with alias + yields splat yields splat + errors if declares extend inside block errors if declares extend inside block + errors if yields from top level errors if yields from top level + reports error if block changes type reports error if block changes type + errors if splat parameter becomes a union errors if splat parameter becomes a union + auto-unpacks tuple, too many args, captured block auto-unpacks tuple, too many args, captured block + renders expected block return type of a free variable on mismatch renders expected block return type of a free variable on mismatch + doesn't mix local var with block var, using next (#2314) doesn't mix local var with block var, using next (#2314) + errors if breaks from captured block errors if breaks from captured block + allows initialize with yield (#224) allows initialize with yield (#224) + errors if invoking new with block when no initialize is defined errors if invoking new with block when no initialize is defined + passes #262 passes #262 + passes #233: block with initialize with default args passes #233: block with initialize with default args + infer type of local variable infer type of local variable + doesn't auto-unpack tuple, more args doesn't auto-unpack tuple, more args + errors on recursive yield with ProcNotation restriction errors on recursive yield with ProcNotation restriction + types bug with yield not_nil! that is never not nil types bug with yield not_nil! that is never not nil + doesn't assign block variable type to last value (#694) doesn't assign block variable type to last value (#694) + infer type with union infer type with union + errors if declares enum inside block errors if declares enum inside block + break from block without value break from block without value + can infer block type given that the method has a return type (#7160) can infer block type given that the method has a return type (#7160) + passes &->f passes &->f + infers type of block with generic type infers type of block with generic type + recalculates call that uses block arg output as free var recalculates call that uses block arg output as free var + reports error if yields a type that's not that one in the block specification reports error if yields a type that's not that one in the block specification + uses splat in block parameter, many args uses splat in block parameter, many args + does next from block without value does next from block without value + allows yielding multiple types when a union is expected allows yielding multiple types when a union is expected + respects block arg restriction when block has a splat parameter (2) (#9524) respects block arg restriction when block has a splat parameter (2) (#9524) + errors on recursive yield with non ProcNotation restriction (#6896) errors on recursive yield with non ProcNotation restriction (#6896) + auto-unpacks tuple, less than max, captured block auto-unpacks tuple, less than max, captured block + ignores void return type (3) (#427) ignores void return type (3) (#427) + ignores void return type (2) (#427) ignores void return type (2) (#427) + uses free var in return type in captured block uses free var in return type in captured block + types empty block types empty block + errors if using Object as block return type (#2358) errors if using Object as block return type (#2358) + uses splat in block parameter, but not enough yield expressions uses splat in block parameter, but not enough yield expressions + uses block var with same name as local var uses block var with same name as local var + doesn't mix local var with block var, using break (#2314) doesn't mix local var with block var, using break (#2314) + binds block return type free variable even if there are no block parameters (#1797) binds block return type free variable even if there are no block parameters (#1797) + auto-unpacks tuple, captured block auto-unpacks tuple, captured block + yields in overload, matches type yields in overload, matches type + doesn't fail with 'already had enclosing call' (#11200) doesn't fail with 'already had enclosing call' (#11200) + errors if using Bar | Object as block return type (#2358) errors if using Bar | Object as block return type (#2358) + allows invoking method on a object of a captured block with a type that was never instantiated allows invoking method on a object of a captured block with a type that was never instantiated + errors if using (Object ->) as block return type (#2358) errors if using (Object ->) as block return type (#2358) + correctly types unpacked tuple block arg after block (#3339) correctly types unpacked tuple block arg after block (#3339) + infers type of block before call taking other args free vars into account infers type of block before call taking other args free vars into account + doesn't crash on cleaning up typeof node without dependencies (#8669) doesn't crash on cleaning up typeof node without dependencies (#8669) + finds type inside module in block finds type inside module in block + does next from block with value does next from block with value + reports error if missing arguments to yield reports error if missing arguments to yield + infer type with self block arg infer type with self block arg + uses block arg, too many parameters uses block arg, too many parameters + allows alias as block fun type allows alias as block fun type + errors if declares def inside block errors if declares def inside block + break without value has nil type break without value has nil type + errors if declares alias inside block errors if declares alias inside block + reports error if block didn't return expected type reports error if block didn't return expected type + errors if declares include inside block errors if declares include inside block + errors if declares module inside block errors if declares module inside block + uses block return type as return type, even if can't infer block type uses block return type as return type, even if can't infer block type + does next from block with value 2 does next from block with value 2 + matches block with generic type and free var matches block with generic type and free var + sets captured block type to that of restriction sets captured block type to that of restriction + ignores void return type (#427) ignores void return type (#427) + auto-unpacks tuple, too many args auto-unpacks tuple, too many args + yields with different types yields with different types + errors if declares macro inside block errors if declares macro inside block + auto-unpacks tuple, captured empty block auto-unpacks tuple, captured empty block + types recursive hash assignment types recursive hash assignment +semantic: case + checks exhaustiveness for tuple literal, and passes checks exhaustiveness for tuple literal, and passes + checks exhaustiveness of enum via const checks exhaustiveness of enum via const + checks exhaustiveness for tuple literal with bool and underscore at first position checks exhaustiveness for tuple literal with bool and underscore at first position + checks exhaustiveness for tuple literal of 2 elements, first is enum checks exhaustiveness for tuple literal of 2 elements, first is enum + checks exhaustiveness for tuple literal with bool and underscore at second position, with partial match checks exhaustiveness for tuple literal with bool and underscore at second position, with partial match + checks exhaustiveness of enum (all cases covered) checks exhaustiveness of enum (all cases covered) + checks exhaustiveness for tuple literal with bool and underscore at first position checks exhaustiveness for tuple literal with bool and underscore at first position + checks exhaustiveness of single type (generic) checks exhaustiveness of single type (generic) + checks exhaustiveness of enum via question method checks exhaustiveness of enum via question method + checks exhaustiveness for tuple literal with bool and underscore at second position checks exhaustiveness for tuple literal with bool and underscore at second position + can't prove case is exhaustive for @[Flags] enum, tuple case can't prove case is exhaustive for @[Flags] enum, tuple case + checks exhaustiveness, covers in base type covers (generic type) checks exhaustiveness, covers in base type covers (generic type) + checks exhaustiveness for tuple literal with bool and underscore at second position checks exhaustiveness for tuple literal with bool and underscore at second position + checks exhaustiveness of enum through method (all cases covered) checks exhaustiveness of enum through method (all cases covered) + can prove case is exhaustive for @[Flags] enum when matching type can prove case is exhaustive for @[Flags] enum when matching type + checks exhaustiveness for tuple literal of 3 elements, all enums checks exhaustiveness for tuple literal of 3 elements, all enums + checks exhaustiveness for tuple literal, with call checks exhaustiveness for tuple literal, with call + checks exhaustiveness of bool type with other types checks exhaustiveness of bool type with other types + checks exhaustiveness, covers in base type covers checks exhaustiveness, covers in base type covers + checks exhaustiveness for tuple literal of 3 elements, and warns checks exhaustiveness for tuple literal of 3 elements, and warns + checks exhaustiveness of bool type (missing true) checks exhaustiveness of bool type (missing true) + checks exhaustiveness for tuple literal with types and underscore at second position checks exhaustiveness for tuple literal with types and underscore at second position + checks exhaustiveness for tuple literal with types and underscore at first position checks exhaustiveness for tuple literal with types and underscore at first position + checks exhaustiveness for tuple literal of 3 elements, all bool checks exhaustiveness for tuple literal of 3 elements, all bool + checks exhaustiveness of union type with virtual type checks exhaustiveness of union type with virtual type + checks exhaustiveness of bool type (missing false) checks exhaustiveness of bool type (missing false) + checks exhaustiveness for tuple literal with bool and underscore at first position, partial match checks exhaustiveness for tuple literal with bool and underscore at first position, partial match + checks exhaustiveness of nil type with nil literal checks exhaustiveness of nil type with nil literal + checks exhaustiveness of nilable type with nil literal checks exhaustiveness of nilable type with nil literal + can't prove case is exhaustive for @[Flags] enum can't prove case is exhaustive for @[Flags] enum + checks exhaustiveness for tuple literal of 2 elements, first is bool checks exhaustiveness for tuple literal of 2 elements, first is bool + checks exhaustiveness of single type (T.class) checks exhaustiveness of single type (T.class) + checks exhaustiveness for tuple literal with bool and underscore at second position, partial match checks exhaustiveness for tuple literal with bool and underscore at second position, partial match + checks exhaustiveness of enum combined with another type checks exhaustiveness of enum combined with another type + checks exhaustiveness for tuple literal of 2 elements, and warns checks exhaustiveness for tuple literal of 2 elements, and warns + checks exhaustiveness for tuple literal with bool and underscore at first position, with partial match checks exhaustiveness for tuple literal with bool and underscore at first position, with partial match + errors if casing against a constant errors if casing against a constant + doesn't check exhaustiveness when using 'when' doesn't check exhaustiveness when using 'when' + checks exhaustiveness of single type (Foo(T).class) checks exhaustiveness of single type (Foo(T).class) + checks exhaustiveness of union with bool checks exhaustiveness of union with bool + checks exhaustiveness of single type checks exhaustiveness of single type + covers all types covers all types +Normalize: array literal + normalizes non-empty with of normalizes non-empty with of + normalizes non-empty without of, with splat only normalizes non-empty without of, with splat only + normalizes empty with of normalizes empty with of + hoists complex element expressions hoists complex element expressions + hoists complex element expressions, with splat hoists complex element expressions, with splat + normalizes non-empty with of, with splat normalizes non-empty with of, with splat + normalizes non-empty without of, with splat normalizes non-empty without of, with splat + hoists complex element expressions, array-like generic hoists complex element expressions, array-like generic + normalizes non-empty without of normalizes non-empty without of + hoists complex element expressions, array-like hoists complex element expressions, array-like +Code gen: uninitialized + codegens value (#3641) codegens value (#3641) + doesn't break on inherited declared var (#390) doesn't break on inherited declared var (#390) + codegens declare var and changes it codegens declare var and changes it + works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) + works with uninitialized NoReturn (#3314) works with uninitialized NoReturn (#3314) + codegens declare instance var with static array type codegens declare instance var with static array type + codegens declare var and read it codegens declare var and read it + codegens declare instance var codegens declare instance var +Semantic: super + types super without arguments and instance variable types super without arguments and instance variable + types super with named arguments, def has bare splat parameter (#8895) types super with named arguments, def has bare splat parameter (#8895) + errors if invoking super and match isn't found in direct superclass in initialize (even though it's find in one superclass) errors if invoking super and match isn't found in direct superclass in initialize (even though it's find in one superclass) + gives correct error when calling super and target is abstract method (#2675) gives correct error when calling super and target is abstract method (#2675) + calls super in module method (3) (#556) calls super in module method (3) (#556) + calls super in module method (2) (#556) calls super in module method (2) (#556) + errors on super outside method (#4481) errors on super outside method (#4481) + calls super in module method (1) (#556) calls super in module method (1) (#556) + types super without arguments types super without arguments + finds super initialize if not explicitly defined in superclass, 1 (#273) finds super initialize if not explicitly defined in superclass, 1 (#273) + types super with named arguments, def has bare splat parameter (2) (#8895) types super with named arguments, def has bare splat parameter (2) (#8895) + errors no superclass method in top-level errors no superclass method in top-level + errors no superclass method in top-level def errors no superclass method in top-level def + errors no superclass method errors no superclass method + types super with forwarded arguments, def has bare splat parameter (#8895) types super with forwarded arguments, def has bare splat parameter (#8895) + finds super initialize if not explicitly defined in superclass, 2 (#273) finds super initialize if not explicitly defined in superclass, 2 (#273) + types super when container method is defined in parent class two levels up types super when container method is defined in parent class two levels up + types super when inside fun and forwards args types super when inside fun and forwards args + doesn't error if invoking super and match isn't found in direct superclass (even though it's find in one superclass) doesn't error if invoking super and match isn't found in direct superclass (even though it's find in one superclass) + calls super in generic module method calls super in generic module method + types super when container method is defined in parent class types super when container method is defined in parent class + types super with forwarded arguments, different internal names (#8895) types super with forwarded arguments, different internal names (#8895) + types super with forwarded arguments, parent has parameters types super with forwarded arguments, parent has parameters + types super with forwarded arguments, def has double splat parameter (#8895) types super with forwarded arguments, def has double splat parameter (#8895) + types super when inside fun types super when inside fun + errors if calling super on module method and not found errors if calling super on module method and not found + errors on super where only target would be a top level method (#5201) errors on super where only target would be a top level method (#5201) + says correct error message when no overload matches in super call (#272) says correct error message when no overload matches in super call (#272) + invokes super inside macro (#6636) invokes super inside macro (#6636) +Crystal::Repl::Interpreter + bugs + doesn't pass self to top-level method doesn't pass self to top-level method + does leading zeros does leading zeros + does multidispatch on virtual struct union nil does multidispatch on virtual struct union nil + doesn't pass self to top-level method (FileNode) doesn't pass self to top-level method (FileNode) + correctly puts virtual metaclass type in union correctly puts virtual metaclass type in union + does multidispatch on virtual struct does multidispatch on virtual struct + doesn't override local variable value with block var with the same name doesn't override local variable value with block var with the same name + breaks from current block, not from outer block breaks from current block, not from outer block + doesn't incorrectly consider a non-closure as closure doesn't incorrectly consider a non-closure as closure +Crystal::Repl::Interpreter + exception handling + does ensure with explicit return does ensure with explicit return + executes ensure when exception is raised in rescue executes ensure when exception is raised in rescue + does ensure for else when else raises does ensure for else when else raises + executes ensure when breaking from a block executes ensure when breaking from a block + raises and rescues specific exception type raises and rescues specific exception type + does ensure without rescue/raise does ensure without rescue/raise + raises and rescues anything raises and rescues anything + executes ensure when returning from a block executes ensure when returning from a block + executes ensure when returning a big value from a block executes ensure when returning a big value from a block + does ensure for else does ensure for else + executes ensure when exception is raised in body executes ensure when exception is raised in body + does else does else + raises and rescues anything, does ensure when an exception is rescued raises and rescues anything, does ensure when an exception is rescued + executes ensure when returning from a block (2) executes ensure when returning from a block (2) + captures exception in variable captures exception in variable + does rescue when nothing is raised does rescue when nothing is raised +Crystal::Doc::Generator + #formatted_summary + with a Deprecated annotation, and docs + should generate both the docs and Deprecated tag should generate both the docs and Deprecated tag + with a Deprecated annotation, and no docs + should generate just the Deprecated tag should generate just the Deprecated tag + with a Experimental annotation, and no docs + should generate just the Experimental tag should generate just the Experimental tag + with no annotation, and no docs + should generate nothing should generate nothing + should generate the first sentence should generate the first sentence + should exclude whitespace before the summary line should exclude whitespace before the summary line + with a Experimental annotation, and docs + should generate both the docs and Experimental tag should generate both the docs and Experimental tag + should generate the first line should generate the first line + generates sitemap generates sitemap + #must_include_toplevel? + returns true if program has method returns true if program has method + returns false if program has macro which is defined in other place returns false if program has macro which is defined in other place + returns false if program has constant which is defined in other place returns false if program has constant which is defined in other place + returns true if program has macro returns true if program has macro + returns false if program has method which is defined in other place returns false if program has method which is defined in other place + returns false if program has nothing returns false if program has nothing + returns true if program has constant returns true if program has constant + #formatted_doc + with a Deprecated annotation, and docs + should generate both the docs and Deprecated tag should generate both the docs and Deprecated tag + should generate the full document should generate the full document + with a Experimental annotation, and docs + should generate both the docs and Experimental tag should generate both the docs and Experimental tag + with no annotation, and no docs + should generate nothing should generate nothing + should generate the full document should generate the full document + with a Experimental annotation, and no docs + should generate just the Experimental tag should generate just the Experimental tag + with a Deprecated annotation, and no docs + should generate just the Deprecated tag should generate just the Deprecated tag + crystal repo + inserts pseudo methods inserts pseudo methods + #collect_constants + returns empty array when constants are private returns empty array when constants are private +Crystal::Repl::Interpreter + blocks + counts with ... yield scope in block args bytesize (#12316) counts with ... yield scope in block args bytesize (#12316) + caches method with captured block (#12276) caches method with captured block (#12276) + interprets yield return value interprets yield return value + interprets break inside block (union, through return) interprets break inside block (union, through return) + interprets yield with splat (1) interprets yield with splat (1) + interprets yield inside def with arguments interprets yield inside def with arguments + interprets yield expressions interprets yield expressions + casts yield expression to block var type (not block arg type) casts yield expression to block var type (not block arg type) + interprets break inside block (union, through normal flow) interprets break inside block (union, through normal flow) + interprets next inside block interprets next inside block + interprets block with splat interprets block with splat + interprets break inside block (union, through break) interprets break inside block (union, through break) + interprets yield with splat, block with splat (#12227) interprets yield with splat, block with splat (#12227) + interprets with ... yield with struct interprets with ... yield with struct + interprets yield with splat, less block arguments interprets yield with splat, less block arguments + captures non-closure block captures non-closure block + interprets block with args that conflict with a local var interprets block with args that conflict with a local var + interprets next inside block (union, through normal exit) interprets next inside block (union, through normal exit) + interprets with ... yield with extra arguments (#12296) interprets with ... yield with extra arguments (#12296) + interprets block with multiple yields interprets block with multiple yields + interprets break inside block interprets break inside block + interprets yield expression interprets yield expression + yields different values to form a union yields different values to form a union + interprets yield with splat (2) interprets yield with splat (2) + clears block local variables when calling block (2) clears block local variables when calling block (2) + considers block arg without type as having NoReturn type (2) (#12270) considers block arg without type as having NoReturn type (2) (#12270) + returns from block returns from block + interprets next inside block (union, through next) interprets next inside block (union, through next) + interprets with ... yield interprets with ... yield + considers block arg without type as having NoReturn type (#12270) considers block arg without type as having NoReturn type (#12270) + interprets block with args that conflict with a local var interprets block with args that conflict with a local var + interprets yield inside another block interprets yield inside another block + clears block local variables when calling block clears block local variables when calling block + interprets simplest block interprets simplest block + discards yield expression discards yield expression + interprets yield with splat, block with splat interprets yield with splat, block with splat +error reporting + reports unexpected named argument reports unexpected named argument + reports unexpected named argument (2) reports unexpected named argument (2) + reports unexpected block reports unexpected block + reports wrong number of arguments, with optional parameters reports wrong number of arguments, with optional parameters + uses correct name for top-level macro methods uses correct name for top-level macro methods + reports wrong number of arguments reports wrong number of arguments + reports missing block reports missing block read_file with absolute path reads file (doesn't exist) reads file (doesn't exist) reads file (exists) reads file (exists) with relative path - reads file (exists) reads file (exists) reads file (doesn't exist) reads file (doesn't exist) + reads file (exists) reads file (exists) +types to_s of + nilable type with more than two elements, Nil at the end nilable type with more than two elements, Nil at the end + does for type contained in generic class does for type contained in generic class + non-instantiated array non-instantiated array + union types + should not have extra parens + in pointers in pointers + in arrays in arrays + in tuples in tuples + should have parens + as return type as return type + as arg type as arg type + nilable reference type nilable reference type + named tuple named tuple + does for type contained in generic module does for type contained in generic module + union of simple types union of simple types + nilable value type nilable value type + array of simple types array of simple types +Lexer comments + lexes without comments enabled lexes without comments enabled + lexes with comments enabled lexes with comments enabled + lexes with comments enabled (2) lexes with comments enabled (2) + lexes correct number of spaces lexes correct number of spaces +Crystal::Loader + .parse + parses directory paths parses directory paths + parses library names parses library names + prepends directory paths before default search paths prepends directory paths before default search paths + parses static parses static + parses file paths parses file paths + .default_search_paths + DYLD_LIBRARY_PATH DYLD_LIBRARY_PATH + LD_LIBRARY_PATH LD_LIBRARY_PATH + .read_ld_conf + basic basic + with include with include + dynlib + #load_library? + library name library name + does not implicitly find dependencies does not implicitly find dependencies + full path full path + lookup in order lookup in order + does not find global symbols does not find global symbols + #load_file? + finds function symbol finds function symbol + validate that lib handles are properly closed validate that lib handles are properly closed +Semantic: virtual metaclass + allows passing metaclass to virtual metaclass restriction allows passing metaclass to virtual metaclass restriction + merges metaclass types merges metaclass types + restricts virtual metaclass to Class (#11376) restricts virtual metaclass to Class (#11376) + allows passing metaclass to virtual metaclass restriction allows passing metaclass to virtual metaclass restriction + types virtual metaclass method types virtual metaclass method + types virtual metaclass types virtual metaclass + yields virtual type in block arg if class is abstract yields virtual type in block arg if class is abstract + merges metaclass types with 3 types merges metaclass types with 3 types + types metaclass node types metaclass node + allows allocating virtual type when base class is abstract allows allocating virtual type when base class is abstract +Semantic: type + errors if original type doesn't support instance variables errors if original type doesn't support instance variables + can call methods of parent type can call methods of parent type + can call methods of original type can call methods of original type + can access instance variables of original type can access instance variables of original type +implementations + find implementation inside contained file private class' class method find implementation inside contained file private class' class method + find full trace for macro expansions find full trace for macro expansions + find method calls inside if find method calls inside if + find const implementation find const implementation + find method calls inside rescue find method calls inside rescue + find alias implementation find alias implementation + find implementation inside contained file private method find implementation inside contained file private method + find class implementation find class implementation + find implementation from macro expansions find implementation from macro expansions + find implementation inside contained class' class method find implementation inside contained class' class method + find open class implementation find open class implementation + find enum value implementation find enum value implementation + find enum implementation find enum implementation + find top level method calls find top level method calls + find method calls inside while cond find method calls inside while cond + find implementors of different classes find implementors of different classes + find method calls inside while find method calls inside while + find struct implementation find struct implementation + find class inside method find class inside method + find implementors of classes that are only used find implementors of classes that are only used + can display json output can display json output + find implementation in generic class methods find implementation in generic class methods + find method calls inside trailing if find method calls inside trailing if + can display text output can display text output + find class defined by macro find class defined by macro + find implementation in generic class find implementation in generic class + find implementation in class methods find implementation in class methods + find module implementation find module implementation + find implementation inside a module class find implementation inside a module class Crystal::Repl::Interpreter - structs - interprets read instance var of struct interprets read instance var of struct - sets multiple instance vars in virtual abstract struct call (#12187) sets multiple instance vars in virtual abstract struct call (#12187) - mutates struct stored in class var mutates struct stored in class var - does allocate, set instance var and get instance var does allocate, set instance var and get instance var - does simple class instance var initializer does simple class instance var initializer - does call receiver by value from VirtualType abstract struct to concrete struct (#12190) does call receiver by value from VirtualType abstract struct to concrete struct (#12190) - inlines struct method that returns self (#12253) inlines struct method that returns self (#12253) - does constructor does constructor - does complex class instance var initializer does complex class instance var initializer - does call receiver by value from VirtualType abstract struct to union does call receiver by value from VirtualType abstract struct to union - casts def body to def type casts def body to def type + downcasts virtual type to its only type (#12351) downcasts virtual type to its only type (#12351) + inlines instance var access from virtual type with a single type (#39520) inlines instance var access from virtual type with a single type (#39520) + classes + calls implicit struct self method calls implicit struct self method discards allocate discards allocate - mutates struct inside union mutates struct inside union - does simple struct instance var initializer does simple struct instance var initializer - does class instance var initializer inheritance does class instance var initializer inheritance -Parser - parses "1+2*3" parses "1+2*3" - parses "def foo(a, @[Foo] &block); end" parses "def foo(a, @[Foo] &block); end" - parses "foo.|(1, 2) { 3 }" parses "foo.|(1, 2) { 3 }" - parses "n <= 2" parses "n <= 2" - parses "break {1 => 2}" parses "break {1 => 2}" - parses "next {1, 2}" parses "next {1, 2}" - parses "def foo(@def); end" parses "def foo(@def); end" - parses "def foo(x @case); end" parses "def foo(x @case); end" - parses "->Foo.>(Int32)" parses "->Foo.>(Int32)" - parses "def foo(@[Foo] *args); end" parses "def foo(@[Foo] *args); end" - says syntax error on "foo { |next| }" says syntax error on "foo { |next| }" - says syntax error on "A = begin; B = 1; end" says syntax error on "A = begin; B = 1; end" - parses "%x(`which(foo)`)" parses "%x(`which(foo)`)" - parses "def >=; end;" parses "def >=; end;" - parses "x = 1; foo x { }" parses "x = 1; foo x { }" - parses "@foo" parses "@foo" - says syntax error on "next >= 1" says syntax error on "next >= 1" - parses "def //(); end" parses "def //(); end" - says syntax error on "def foo(foo yield); end" says syntax error on "def foo(foo yield); end" - parses "begin\n1\nensure\n2\nend" parses "begin\n1\nensure\n2\nend" - says syntax error on "next >> 1" says syntax error on "next >> 1" - parses "return *{1, 2}" parses "return *{1, 2}" - parses "Foo({X: X, Y: Y})" parses "Foo({X: X, Y: Y})" - parses "def foo(x y); y; end" parses "def foo(x y); y; end" - parses "def **(); end;" parses "def **(); end;" - parses "macro foo\n{%\nif 1\n2\nelse\n3\nend\n%}end" parses "macro foo\n{%\nif 1\n2\nelse\n3\nend\n%}end" - parses "false" parses "false" - parses ":/" parses ":/" - parses "foo.& 1, 2" parses "foo.& 1, 2" - says syntax error on "def foo x y; end" says syntax error on "def foo x y; end" - parses "::foo" parses "::foo" - parses "n & 2" parses "n & 2" - parses ":\u304B\u305F\u306A" parses ":\u304B\u305F\u306A" - says syntax error on "return[0]= 1" says syntax error on "return[0]= 1" - parses "foo.[0] = 1" parses "foo.[0] = 1" - parses "def foo(alias foo); end" parses "def foo(alias foo); end" - says syntax error on "break ... 1" says syntax error on "break ... 1" - parses "def foo(x @@if); end" parses "def foo(x @@if); end" - parses "a.b /=\n1" parses "a.b /=\n1" - parses "Foo()?" parses "Foo()?" - parses "foo[] /2" parses "foo[] /2" - parses "instance_alignof(\n Int32\n)" parses "instance_alignof(\n Int32\n)" - says syntax error on "foo { |a b| }" says syntax error on "foo { |a b| }" - parses "Foo(X, instance_sizeof(Int32))" parses "Foo(X, instance_sizeof(Int32))" - parses "foo[\n1\n]" parses "foo[\n1\n]" - parses "f.x **= 2" parses "f.x **= 2" - says syntax error on "*a if true = 2" says syntax error on "*a if true = 2" - parses "Foo?" parses "Foo?" - parses "a = 1; a +=\n1" parses "a = 1; a +=\n1" - says syntax error on "yield break" says syntax error on "yield break" - parses "foo = 1; foo {}" parses "foo = 1; foo {}" - parses "foo %i()" parses "foo %i()" - parses "foo(a: n < 2)" parses "foo(a: n < 2)" - parses "def +; end;" parses "def +; end;" - says syntax error on "next % 1" says syntax error on "next % 1" - parses "def foo\n1\nend" parses "def foo\n1\nend" - parses "def foo(@[Foo] @[Bar] var : Int32); end" parses "def foo(@[Foo] @[Bar] var : Int32); end" - parses "asm(\"nop\" ::)" parses "asm(\"nop\" ::)" - parses "macro x\n%{}\nend" parses "macro x\n%{}\nend" - parses "lib LibC\nfun getchar : (->)?\nend" parses "lib LibC\nfun getchar : (->)?\nend" - says syntax error on "def is_a?; end" says syntax error on "def is_a?; end" - says syntax error on "def foo(foo unless); end" says syntax error on "def foo(foo unless); end" - parses "def foo(x @@alias); end" parses "def foo(x @@alias); end" - says syntax error on "foo { |(class)| }" says syntax error on "foo { |(class)| }" - parses "1.!(\n)" parses "1.!(\n)" - parses "foo%i" parses "foo%i" - says syntax error on "foo &.&&()" says syntax error on "foo &.&&()" - says syntax error on "<<-'HERE\n" says syntax error on "<<-'HERE\n" - parses "lib LibC\nfun getch = \"get.char\" : Int32\nend" parses "lib LibC\nfun getch = \"get.char\" : Int32\nend" - says syntax error on "a = return" says syntax error on "a = return" - parses "def foo(x @out); end" parses "def foo(x @out); end" - parses "a = 1; a /= 1" parses "a = 1; a /= 1" - parses "a.b &=\n1" parses "a.b &=\n1" - parses "->Foo.&(Int32)" parses "->Foo.&(Int32)" - parses "def self.!~; end;" parses "def self.!~; end;" - says syntax error on "{a[]: 1}" says syntax error on "{a[]: 1}" - parses "def foo(@@yield); end" parses "def foo(@@yield); end" - parses "foo(a: n / 2)" parses "foo(a: n / 2)" - says syntax error on "foo { |(a b)| }" says syntax error on "foo { |(a b)| }" - parses "macro -;end" parses "macro -;end" - parses "foo = 1; b = 2; foo -b" parses "foo = 1; b = 2; foo -b" - parses "next *1" parses "next *1" - parses "def foo(x @@while); end" parses "def foo(x @@while); end" - parses "def foo(x @begin); end" parses "def foo(x @begin); end" - says syntax error on "foo **bar, *x" says syntax error on "foo **bar, *x" - parses "abstract def foo; 1" parses "abstract def foo; 1" - parses "Foo(x: U, y: V)" parses "Foo(x: U, y: V)" - says syntax error on "def foo(foo lib); end" says syntax error on "def foo(foo lib); end" - parses "return 1, *2" parses "return 1, *2" - says syntax error on "case 1 == 1; when 2 a; end" says syntax error on "case 1 == 1; when 2 a; end" - says syntax error on "break.as(Int32)" says syntax error on "break.as(Int32)" - parses "property require : Int32" parses "property require : Int32" - parses "macro foo;var if true;end" parses "macro foo;var if true;end" - parses "*a = 1" parses "*a = 1" - parses "def foo(x @unless); end" parses "def foo(x @unless); end" - parses "foo(0, n | 2)" parses "foo(0, n | 2)" - parses "def foo(@alias); end" parses "def foo(@alias); end" - parses "macro *;end" parses "macro *;end" - says syntax error on "[\n\"foo\"\n\"bar\"\n]" says syntax error on "[\n\"foo\"\n\"bar\"\n]" - says syntax error on "foo(break)" says syntax error on "foo(break)" - says syntax error on "break << 1" says syntax error on "break << 1" - parses "def foo(x : U) forall U; end" parses "def foo(x : U) forall U; end" - parses "n << 2" parses "n << 2" - says syntax error on "def foo(enum); end" says syntax error on "def foo(enum); end" - parses "{% begin %}%r{\\A}{% end %}" parses "{% begin %}%r{\\A}{% end %}" - global regex match data - says syntax error on "$99999999999999999999999?" says syntax error on "$99999999999999999999999?" - parses "$?" parses "$?" - says syntax error on "$0, $1 = [1, 2]" says syntax error on "$0, $1 = [1, 2]" - parses "$? = 1" parses "$? = 1" - parses "$~ = 1" parses "$~ = 1" - parses "$?.foo" parses "$?.foo" - parses "$1" parses "$1" - says syntax error on "$0, a = {1, 2}" says syntax error on "$0, a = {1, 2}" - parses "$~.foo" parses "$~.foo" - parses "foo $?" parses "foo $?" - parses "$1?" parses "$1?" - parses "foo $1" parses "foo $1" - says syntax error on "$0 = 1" says syntax error on "$0 = 1" - parses "$~" parses "$~" - parses "$0" parses "$0" - says syntax error on "$2147483648" says syntax error on "$2147483648" - parses "property if : Int32" parses "property if : Int32" - parses "foo(0, n % 2)" parses "foo(0, n % 2)" - parses "[1,\n 2,]" parses "[1,\n 2,]" - parses "->Foo.[]=(Int32)" parses "->Foo.[]=(Int32)" - parses "foo(0, n &* 2)" parses "foo(0, n &* 2)" - parses "as(Bar)" parses "as(Bar)" - says syntax error on "foo { |(true)| }" says syntax error on "foo { |(true)| }" - parses "(1; 2; 3)" parses "(1; 2; 3)" - says syntax error on "def foo 1; end" says syntax error on "def foo 1; end" - parses "def ===(); end" parses "def ===(); end" - parses "a : Foo" parses "a : Foo" - parses "instance_sizeof(\n Int32\n)" parses "instance_sizeof(\n Int32\n)" - parses "lib LibC; fun foo(a : Int*); end" parses "lib LibC; fun foo(a : Int*); end" - parses "def foo(@case); end" parses "def foo(@case); end" - parses "case 1; when 0, 1; 2; else; 3; end" parses "case 1; when 0, 1; 2; else; 3; end" - parses "def foo; yield 1; yield; end" parses "def foo; yield 1; yield; end" - parses "a = 1; b = 2; c = 3; a-b -c" parses "a = 1; b = 2; c = 3; a-b -c" - parses "lib LibC; struct Foo; x : Int; y : Float; end end" parses "lib LibC; struct Foo; x : Int; y : Float; end end" - parses "puts %i(one two)" parses "puts %i(one two)" - parses "def ~(); end;" parses "def ~(); end;" - parses "fun : Int32" parses "fun : Int32" - says syntax error on "break - 1" says syntax error on "break - 1" - parses "foo &.block[0]" parses "foo &.block[0]" - parses "case :foo; when :bar; 2; end" parses "case :foo; when :bar; 2; end" - parses "def !~(); end;" parses "def !~(); end;" - says syntax error on "foo { |extend| }" says syntax error on "foo { |extend| }" - says syntax error on "def foo(foo self); end" says syntax error on "def foo(foo self); end" - says syntax error on "def foo(def); end" says syntax error on "def foo(def); end" - parses "call(foo : A, end : B)" parses "call(foo : A, end : B)" - parses "foo.| do end" parses "foo.| do end" - parses "foo(0, n &- 2)" parses "foo(0, n &- 2)" - parses "\"foo\#{\"bar\"}baz\"" parses "\"foo\#{\"bar\"}baz\"" - parses "foo 1, a: 1, b: 2\n1" parses "foo 1, a: 1, b: 2\n1" - parses "foo.** do end" parses "foo.** do end" - parses "foo % x()" parses "foo % x()" - parses "foo.<=(1, 2)" parses "foo.<=(1, 2)" - parses "lib LibC\nfun SomeFun\nend" parses "lib LibC\nfun SomeFun\nend" - parses "def ==(*args, **opts, &); end" parses "def ==(*args, **opts, &); end" - sets correct location of annotation in lib sets correct location of annotation in lib - says syntax error on "{{ {{ 1 }} }}" says syntax error on "{{ {{ 1 }} }}" - says syntax error on "{one: :two, three: :four} of Symbol => Symbol" says syntax error on "{one: :two, three: :four} of Symbol => Symbol" - parses "<<-HERE\n One\n Zero\n HERE" parses "<<-HERE\n One\n Zero\n HERE" - parses "<<-HERE\n foo\#{1}bar\n baz\n HERE" parses "<<-HERE\n foo\#{1}bar\n baz\n HERE" - parses "macro |;end" parses "macro |;end" - parses "lib LibC\n@[Bar]; end" parses "lib LibC\n@[Bar]; end" - parses "class Foo(T); end" parses "class Foo(T); end" - says syntax error on "def foo(until); end" says syntax error on "def foo(until); end" - parses "foo /a/" parses "foo /a/" - parses "foo.% do end" parses "foo.% do end" - parses "next *1, 2" parses "next *1, 2" - parses "foo = 1; ->foo.foo=" parses "foo = 1; ->foo.foo=" - parses "asm(\n\"nop\"\n:\n\"a\"(0)\n:\n\"b\"(1),\n\"c\"(2)\n)" parses "asm(\n\"nop\"\n:\n\"a\"(0)\n:\n\"b\"(1),\n\"c\"(2)\n)" - parses "def foo(@@var); end" parses "def foo(@@var); end" - parses "asm(\"nop\" : : )" parses "asm(\"nop\" : : )" - says syntax error on "foo { |typeof| }" says syntax error on "foo { |typeof| }" - says syntax error on "foo { |(struct)| }" says syntax error on "foo { |(struct)| }" - says syntax error on "fun Foo : Int64\nend" says syntax error on "fun Foo : Int64\nend" - parses "macro foo;bar{% if x %}body{% elsif y %}body2{% else %}body3{%end%}baz;end" parses "macro foo;bar{% if x %}body{% elsif y %}body2{% else %}body3{%end%}baz;end" - parses "<<-FOO\n\t 1\n\t FOO" parses "<<-FOO\n\t 1\n\t FOO" - parses "->@@foo.foo=" parses "->@@foo.foo=" - parses "lib LibC; type A = B.class; end" parses "lib LibC; type A = B.class; end" - parses "rescue : Int32" parses "rescue : Int32" - says syntax error on "def foo(x, *); 1; end" says syntax error on "def foo(x, *); 1; end" - parses "foo[0] = 1 if 2" parses "foo[0] = 1 if 2" - parses "%r(/)" parses "%r(/)" - says syntax error on "def foo(out); end" says syntax error on "def foo(out); end" - parses "foo &.+(2)" parses "foo &.+(2)" - parses "return 1, 2" parses "return 1, 2" - parses "a = 1\ncase 1\nwhen a then 1\nend" parses "a = 1\ncase 1\nwhen a then 1\nend" - says syntax error on "{a: 1, \"\": 2}" says syntax error on "{a: 1, \"\": 2}" - parses "foo.^ do end" parses "foo.^ do end" - parses "def foo(@@lib); end" parses "def foo(@@lib); end" - says syntax error on " {1, 2, 3 end" says syntax error on " {1, 2, 3 end" - parses "foo.%(1, 2) { 3 }" parses "foo.%(1, 2) { 3 }" - says syntax error on "class Foo(T, U V)" says syntax error on "class Foo(T, U V)" - parses "Int" parses "Int" - says syntax error on "def foo(**x, &x); end" says syntax error on "def foo(**x, &x); end" - parses "def type(type); end" parses "def type(type); end" - parses "1 / -2" parses "1 / -2" - parses "foo bar.baz(1) do\nend" parses "foo bar.baz(1) do\nend" - parses "asm(\"nop\" \n)" parses "asm(\"nop\" \n)" - says syntax error on "require 1" says syntax error on "require 1" - parses "foo(Bar) { 1 }" parses "foo(Bar) { 1 }" - parses "foo x, y do\nend" parses "foo x, y do\nend" - parses "foo.!~(1, 2)" parses "foo.!~(1, 2)" - parses "lib LibC; fun foo : Int*; end" parses "lib LibC; fun foo : Int*; end" - parses "{% begin %}%i| %s |{% end %}" parses "{% begin %}%i| %s |{% end %}" - parses "abstract struct Foo; end" parses "abstract struct Foo; end" - parses "1 .. 2" parses "1 .. 2" - parses "def <=; end;" parses "def <=; end;" - parses "f ->{ a do\n end\n }" parses "f ->{ a do\n end\n }" - parses "def foo(@@break); end" parses "def foo(@@break); end" - parses "@a = uninitialized Foo" parses "@a = uninitialized Foo" - parses ":<=" parses ":<=" - parses "foo.bar.as(Bar)" parses "foo.bar.as(Bar)" - parses "yield if true" parses "yield if true" - parses "foo.< do end" parses "foo.< do end" - parses "foo(0, n - 2)" parses "foo(0, n - 2)" - says syntax error on "{a: 1, a: 2}" says syntax error on "{a: 1, a: 2}" - parses "Foo(\n)" parses "Foo(\n)" - parses " def foo(\n @[Foo]\n id : Int32,\n @[Bar] name : String\n ); end" parses " def foo(\n @[Foo]\n id : Int32,\n @[Bar] name : String\n ); end" - parses "->::foo?" parses "->::foo?" - parses "def foo(x @alias); end" parses "def foo(x @alias); end" - parses "macro <;end" parses "macro <;end" - says syntax error on "foo **bar, out x" says syntax error on "foo **bar, out x" - says syntax error on "def foo(include); end" says syntax error on "def foo(include); end" - says syntax error on "1 while 3" says syntax error on "1 while 3" - parses "foo a: 1, b: 2" parses "foo a: 1, b: 2" - parses "def foo(@self); end" parses "def foo(@self); end" - parses "foo % r()" parses "foo % r()" - parses "a = 1; a ||= 1" parses "a = 1; a ||= 1" - parses "def self./; end;" parses "def self./; end;" - parses "def !=; end;" parses "def !=; end;" - parses "yield 1" parses "yield 1" - parses "foo.^" parses "foo.^" - parses "/ /\n/ /" parses "/ /\n/ /" - parses "foo.!= 1, 2" parses "foo.!= 1, 2" - says syntax error on "foo { |lib| }" says syntax error on "foo { |lib| }" - parses "->foo(Int32, Float64)" parses "->foo(Int32, Float64)" - parses "begin; 1; rescue; 2; else; 3; end" parses "begin; 1; rescue; 2; else; 3; end" - parses "macro &;end" parses "macro &;end" - parses "1 <= 2 <= 3" parses "1 <= 2 <= 3" - parses "property else : Int32" parses "property else : Int32" - parses "foo begin\nbar do\nend\nend" parses "foo begin\nbar do\nend\nend" - parses "Foo(X: U, Y: V)" parses "Foo(X: U, Y: V)" - says syntax error on "{foo: 1, bar: 2\nbaz: 3}" says syntax error on "{foo: 1, bar: 2\nbaz: 3}" - parses "def foo(x @@class); end" parses "def foo(x @@class); end" - parses "x : *T -> R" parses "x : *T -> R" - parses "1 ? a : b" parses "1 ? a : b" - parses "<<-HERE\n One\n\n Zero\n HERE" parses "<<-HERE\n One\n\n Zero\n HERE" - parses "foo(0, n < 2)" parses "foo(0, n < 2)" - parses "1 / 2" parses "1 / 2" - says syntax error on "macro foo(x, *); 1; end" says syntax error on "macro foo(x, *); 1; end" - parses "property alias : Int32" parses "property alias : Int32" - parses "next" parses "next" - says syntax error on "x++" says syntax error on "x++" - parses "Foo({String, ->})" parses "Foo({String, ->})" - parses "def =~; end;" parses "def =~; end;" - says syntax error on "def foo(alias); end" says syntax error on "def foo(alias); end" - parses "def foo(x @@struct); end" parses "def foo(x @@struct); end" - parses "foo.>=(1, 2)" parses "foo.>=(1, 2)" - says syntax error on "*a, b, c, d, e = 1, 2" says syntax error on "*a, b, c, d, e = 1, 2" - parses "def foo(var : (Int, Float -> Double)); end" parses "def foo(var : (Int, Float -> Double)); end" - parses "def foo(x @@with); end" parses "def foo(x @@with); end" - parses "def foo(&block : Int ->\n); end" parses "def foo(&block : Int ->\n); end" - parses "property false : Int32" parses "property false : Int32" - parses "def foo; 1; 2; end" parses "def foo; 1; 2; end" - says syntax error on "def foo(foo protected); end" says syntax error on "def foo(foo protected); end" - parses "def foo(macro foo); end" parses "def foo(macro foo); end" - parses "def self.<(); end;" parses "def self.<(); end;" - parses "def foo(@@offsetof); end" parses "def foo(@@offsetof); end" - parses "class : Int32" parses "class : Int32" - says syntax error on "foo &.&&" says syntax error on "foo &.&&" - parses "{% begin %}%Q< %s >{% end %}" parses "{% begin %}%Q< %s >{% end %}" - parses "def foo;bar(end: 1);end" parses "def foo;bar(end: 1);end" - parses "\"hello \" \\\n \"world\"" parses "\"hello \" \\\n \"world\"" - says syntax error on "def foo(yield); end" says syntax error on "def foo(yield); end" - parses "macro foo;bar{% unless x %}body{% end %}baz;end" parses "macro foo;bar{% unless x %}body{% end %}baz;end" - parses "foo(n / 2)" parses "foo(n / 2)" - parses "def foo(@@asm); end" parses "def foo(@@asm); end" - parses "lib LibC\nfun getchar(a : Int)\nend" parses "lib LibC\nfun getchar(a : Int)\nend" - parses "1_i64" parses "1_i64" - parses "fun foo(x : Int32) : Int64\nx\nend" parses "fun foo(x : Int32) : Int64\nx\nend" - says syntax error on "fun foo\nFoo = 1" says syntax error on "fun foo\nFoo = 1" - says syntax error on "def foo!=; end" says syntax error on "def foo!=; end" - says syntax error on "/foo)/" says syntax error on "/foo)/" - parses "<<-HERE\nHello, mom! I am HERE.\nHER dress is beautiful.\nHE is OK.\n HERESY\nHERE" parses "<<-HERE\nHello, mom! I am HERE.\nHER dress is beautiful.\nHE is OK.\n HERESY\nHERE" - parses "->Foo.+(Int32)" parses "->Foo.+(Int32)" - parses "foo = 1; ->foo.[](Int32)" parses "foo = 1; ->foo.[](Int32)" - parses "def foo(@[Foo] **args); end" parses "def foo(@[Foo] **args); end" - parses "::Foo{\"x\" => \"y\"}" parses "::Foo{\"x\" => \"y\"}" - parses "foo(x: result : Int32); result" parses "foo(x: result : Int32); result" - parses "a.b &-=\n1" parses "a.b &-=\n1" - parses "a ?\n b ? b1 : b2\n : c ? 3\n : 0" parses "a ?\n b ? b1 : b2\n : c ? 3\n : 0" - parses "def foo(x @until); end" parses "def foo(x @until); end" - parses "a : Foo | Int32" parses "a : Foo | Int32" - says syntax error on "while next; end" says syntax error on "while next; end" - parses "foo(*bar)" parses "foo(*bar)" - parses "{% begin %}%q( %s ){% end %}" parses "{% begin %}%q( %s ){% end %}" - parses "lib LibC; struct Foo; include Bar; end; end" parses "lib LibC; struct Foo; include Bar; end; end" - says syntax error on "{1 2}" says syntax error on "{1 2}" - says syntax error on "pointerof(self)" says syntax error on "pointerof(self)" - parses "def !=(*args, **opts); end" parses "def !=(*args, **opts); end" - parses "def foo(@protected); end" parses "def foo(@protected); end" - parses "def foo;{{@type}};end" parses "def foo;{{@type}};end" - parses "{% begin %}%x[ %s ]{% end %}" parses "{% begin %}%x[ %s ]{% end %}" - parses "a = 1; a rescue a" parses "a = 1; a rescue a" - parses "asm(\n\"nop\"\n:\n\"a\"(0),\n\"b\"(1)\n:\n\"c\"(2),\n\"d\"(3)\n)" parses "asm(\n\"nop\"\n:\n\"a\"(0),\n\"b\"(1)\n:\n\"c\"(2),\n\"d\"(3)\n)" - parses "case {1}\nin {_}; 2; end" parses "case {1}\nin {_}; 2; end" - parses "foo = 1; ->foo.<<(Int32)" parses "foo = 1; ->foo.<<(Int32)" - parses "foo(\n1)" parses "foo(\n1)" - parses "foo x, *bar" parses "foo x, *bar" - parses "foo &.block" parses "foo &.block" - parses "offsetof(X, 1)" parses "offsetof(X, 1)" - says syntax error on "{a: 1 b: 2}" says syntax error on "{a: 1 b: 2}" - parses "foo(a: 1\n)" parses "foo(a: 1\n)" - parses "property rescue : Int32" parses "property rescue : Int32" - parses "def self.===; end;" parses "def self.===; end;" - says syntax error on "foo[break]" says syntax error on "foo[break]" - says syntax error on "break | 1" says syntax error on "break | 1" - parses "macro foo; 1 + 2 {{ foo }} 3 + 4; end" parses "macro foo; 1 + 2 {{ foo }} 3 + 4; end" - parses "1 ? a : b ? c : 3" parses "1 ? a : b ? c : 3" - parses "@@foo/2" parses "@@foo/2" - says syntax error on "module Foo; require \"bar\"; end" says syntax error on "module Foo; require \"bar\"; end" - parses "->Foo.foo" parses "->Foo.foo" - parses "Foo({X, Y})" parses "Foo({X, Y})" - says syntax error on "return &+ 1" says syntax error on "return &+ 1" - says syntax error on "foo 1," says syntax error on "foo 1," - parses "lib LibC; struct Foo; end end" parses "lib LibC; struct Foo; end end" - parses "Foo(T)" parses "Foo(T)" - parses "/fo\\so/" parses "/fo\\so/" - parses "a = 1; a %= 1" parses "a = 1; a %= 1" - says syntax error on "foo { |class| }" says syntax error on "foo { |class| }" - parses "def foo(\"bar qux\" y); y; end" parses "def foo(\"bar qux\" y); y; end" - parses "def foo(sizeof foo); end" parses "def foo(sizeof foo); end" - parses "{\n{1}\n}" parses "{\n{1}\n}" - parses "foo(z: 0, a: n =~ 2)" parses "foo(z: 0, a: n =~ 2)" - says syntax error on "foo { |(case)| }" says syntax error on "foo { |(case)| }" - parses "1\n+2" parses "1\n+2" - says syntax error on "$foo :: Foo" says syntax error on "$foo :: Foo" - parses "{% begin %}%w( %s ){% end %}" parses "{% begin %}%w( %s ){% end %}" - says syntax error on "foo { |protected| }" says syntax error on "foo { |protected| }" - parses "def foo(a, &block : Int -> Double); end" parses "def foo(a, &block : Int -> Double); end" - parses "lib LibC\nfun getch = \"get.char\"\nend" parses "lib LibC\nfun getch = \"get.char\"\nend" - parses "def foo(nil foo); end" parses "def foo(nil foo); end" - parses "foo(z: 0, a: n << 2)" parses "foo(z: 0, a: n << 2)" - parses "__FILE__" parses "__FILE__" - parses "1.responds_to?(\n :foo\n)" parses "1.responds_to?(\n :foo\n)" - parses "case : Int32" parses "case : Int32" - parses "puts a if true" parses "puts a if true" - says syntax error on "a() = 1" says syntax error on "a() = 1" - parses "(a;\nb)" parses "(a;\nb)" - says syntax error on "A = foo(B = 1)" says syntax error on "A = foo(B = 1)" - parses "foo.is_a?(Foo | Bar)" parses "foo.is_a?(Foo | Bar)" - says syntax error on "unless next; end" says syntax error on "unless next; end" - parses "foo(bar:\"a\", baz:\"b\")" parses "foo(bar:\"a\", baz:\"b\")" - parses "a = 1; a ^=\n1" parses "a = 1; a ^=\n1" - parses "foo %q()" parses "foo %q()" - says syntax error on "return &* 1" says syntax error on "return &* 1" - parses "def foo(@@self); end" parses "def foo(@@self); end" - parses "def foo(@begin); end" parses "def foo(@begin); end" - parses "{% for x in y %}body{% end %}" parses "{% for x in y %}body{% end %}" - says syntax error on "foo { |enum| }" says syntax error on "foo { |enum| }" - parses "def >; end;" parses "def >; end;" - says syntax error on "break >> 1" says syntax error on "break >> 1" - parses "{% a = 1 if 2 %}" parses "{% a = 1 if 2 %}" - says syntax error on "return ? 1 : 2" says syntax error on "return ? 1 : 2" - parses "case {1, 2}\nwhen {.foo, .bar}\n5\nend" parses "case {1, 2}\nwhen {.foo, .bar}\n5\nend" - parses "def foo(var : self*); end" parses "def foo(var : self*); end" - says syntax error on "def foo=(**kwargs); end" says syntax error on "def foo=(**kwargs); end" - parses "1 if /x/" parses "1 if /x/" - says syntax error on "def foo(x @x); 1; end" says syntax error on "def foo(x @x); 1; end" - says syntax error on "{\"x\": [] of Int32,\n}\n1.foo(" says syntax error on "{\"x\": [] of Int32,\n}\n1.foo(" - parses "/=/" parses "/=/" - parses "def foo(@yield); end" parses "def foo(@yield); end" - parses "Foo.bar x.y do\nend" parses "Foo.bar x.y do\nend" - parses "foo do\n//\nend" parses "foo do\n//\nend" - says syntax error on "a = a" says syntax error on "a = a" - parses "def !=(*args, **opts, &); end" parses "def !=(*args, **opts, &); end" - parses "macro //;end" parses "macro //;end" - says syntax error on "a = 1, b = 2" says syntax error on "a = 1, b = 2" - parses "def foo(include foo); end" parses "def foo(include foo); end" - parses "self" parses "self" - parses "def foo(x = __FILE__); end" parses "def foo(x = __FILE__); end" - parses "def foo(x @self); end" parses "def foo(x @self); end" - parses "Foo(Bar(T | U))" parses "Foo(Bar(T | U))" - parses "foo(n &** 2)" parses "foo(n &** 2)" - parses "def self.foo\n1\nend" parses "def self.foo\n1\nend" - says syntax error on "class Foo; require \"bar\"; end" says syntax error on "class Foo; require \"bar\"; end" - parses "def foo(@@case); end" parses "def foo(@@case); end" - parses "def <=(); end;" parses "def <=(); end;" - says syntax error on "offsetof(X, 1.0)" says syntax error on "offsetof(X, 1.0)" - parses "def foo(@@next); end" parses "def foo(@@next); end" - parses "def foo(x @@end); end" parses "def foo(x @@end); end" - parses "def foo(x @include); end" parses "def foo(x @include); end" - parses "{A::B => 1, C::D => 2}" parses "{A::B => 1, C::D => 2}" - parses "def foo(x @asm); end" parses "def foo(x @asm); end" - says syntax error on "@@foo :: Foo" says syntax error on "@@foo :: Foo" - parses "def foo(x, **args)\n1\nend" parses "def foo(x, **args)\n1\nend" - says syntax error on "def foo(**args = 1); end" says syntax error on "def foo(**args = 1); end" - parses "foo &.as?(T).bar" parses "foo &.as?(T).bar" - parses "yield foo do\nend" parses "yield foo do\nend" - parses "foo(out x); x" parses "foo(out x); x" - parses "f.x %= 2" parses "f.x %= 2" - parses "def =~; end" parses "def =~; end" - parses "foo.bar = (1).abs" parses "foo.bar = (1).abs" - parses "/ /; / /" parses "/ /; / /" - parses "{% begin %}%Q( %s ){% end %}" parses "{% begin %}%Q( %s ){% end %}" - parses "begin\n/ /\nend" parses "begin\n/ /\nend" - parses "foo.<" parses "foo.<" - parses "{% begin %}%q| %s |{% end %}" parses "{% begin %}%q| %s |{% end %}" - parses "+1_i64" parses "+1_i64" - parses "foo +1" parses "foo +1" - parses "protected def foo; end" parses "protected def foo; end" - parses "<<-FOO\n\t1\n\tFOO" parses "<<-FOO\n\t1\n\tFOO" - parses "macro foo;if var;true;end;end" parses "macro foo;if var;true;end;end" - parses "1 && 2" parses "1 && 2" - says syntax error on "case break; when 1; end; end" says syntax error on "case break; when 1; end; end" - parses "Foo()" parses "Foo()" - says syntax error on "a.b {}, c = 1" says syntax error on "a.b {}, c = 1" - parses "foo &.!" parses "foo &.!" - parses ":\"\\\\foo\"" parses ":\"\\\\foo\"" - parses "def foo; end; if false; 1; else; 2; end" parses "def foo; end; if false; 1; else; 2; end" - parses "def foo(@@out); end" parses "def foo(@@out); end" - parses "lib LibC; struct Foo; {% if 1 %}2{% end %}; end; end" parses "lib LibC; struct Foo; {% if 1 %}2{% end %}; end; end" - parses "f.x &-= 2" parses "f.x &-= 2" - says syntax error on "return >= 1" says syntax error on "return >= 1" - parses "foo % i()" parses "foo % i()" - parses "def foo(begin foo); end" parses "def foo(begin foo); end" - parses "def ==(*args, **opts); end" parses "def ==(*args, **opts); end" - parses "foo.>= do end" parses "foo.>= do end" - says syntax error on "def foo\ndef\nend" says syntax error on "def foo\ndef\nend" - parses "foo(\na: 1,\n)" parses "foo(\na: 1,\n)" - parses "def foo(x @select); end" parses "def foo(x @select); end" - parses "foo.%(1, 2)" parses "foo.%(1, 2)" - parses "foo(a: n % 2)" parses "foo(a: n % 2)" - parses "{{ //.options }}" parses "{{ //.options }}" - parses "x[+ 1]" parses "x[+ 1]" - parses "Foo.foo(count: 3).bar { }" parses "Foo.foo(count: 3).bar { }" - parses "def foo(offsetof foo); end" parses "def foo(offsetof foo); end" - parses "a, *b = 1" parses "a, *b = 1" - parses "foo.===" parses "foo.===" - parses "begin; rescue; end" parses "begin; rescue; end" - parses "case {1, 2}\nwhen {3, 4}, {5, 6}\n7\nend" parses "case {1, 2}\nwhen {3, 4}, {5, 6}\n7\nend" - parses "foo(a: n &- 2)" parses "foo(a: n &- 2)" - parses "foo = 1; ->foo.foo!" parses "foo = 1; ->foo.foo!" - parses ":!" parses ":!" - parses "def foo(var : Int, Float -> Double); end" parses "def foo(var : Int, Float -> Double); end" - parses "break" parses "break" - parses "macro foo(x); 1 + 2; end" parses "macro foo(x); 1 + 2; end" - parses "property begin : Int32" parses "property begin : Int32" - parses ":|" parses ":|" - parses "Foo({*X, *{Y}})" parses "Foo({*X, *{Y}})" - parses "def foo(x @var); end" parses "def foo(x @var); end" - sets correct location of splat in multiple assignment sets correct location of splat in multiple assignment - parses "while true; 1; end;" parses "while true; 1; end;" - parses "typeof : Int32" parses "typeof : Int32" - says syntax error on "next - 1" says syntax error on "next - 1" - parses "foo a: 1, &block" parses "foo a: 1, &block" - parses "case {1}\nin {true}; 2; end" parses "case {1}\nin {true}; 2; end" - parses "[] of ->\n" parses "[] of ->\n" - parses "a.b %=\n1" parses "a.b %=\n1" - parses "n == 2" parses "n == 2" - parses "foo.==(1, 2) { 3 }" parses "foo.==(1, 2) { 3 }" - says syntax error on "x, self = 1, 2" says syntax error on "x, self = 1, 2" - parses "def foo(@@module); end" parses "def foo(@@module); end" - says syntax error on "def Foo(Int32).bar;end" says syntax error on "def Foo(Int32).bar;end" - parses "1;-2" parses "1;-2" - parses "foo.[]=(1, 2) { 3 }" parses "foo.[]=(1, 2) { 3 }" - parses "def downto(n)\n1\nend" parses "def downto(n)\n1\nend" - says syntax error on "foo { |(out)| }" says syntax error on "foo { |(out)| }" - parses "def foo(@module); end" parses "def foo(@module); end" - parses "n - 2" parses "n - 2" - parses "begin; 1; rescue ::Foo; 2; end" parses "begin; 1; rescue ::Foo; 2; end" - parses "a; if / /; / /; elsif / /; / /; end" parses "a; if / /; / /; elsif / /; / /; end" - says syntax error on "foo { |if| }" says syntax error on "foo { |if| }" - says syntax error on "a = next" says syntax error on "a = next" - parses "->(x : Int32) : Int32 { }" parses "->(x : Int32) : Int32 { }" - parses "def self.^(); end;" parses "def self.^(); end;" - parses "foo.!=(1, 2)" parses "foo.!=(1, 2)" - says syntax error on "*a == 1" says syntax error on "*a == 1" - says syntax error on "unless 1 == 1 a; end" says syntax error on "unless 1 == 1 a; end" - parses "->foo(Void*)" parses "->foo(Void*)" - parses "foo(**bar)" parses "foo(**bar)" - parses "def foo(@select); end" parses "def foo(@select); end" - parses "def foo; x { |a| a }; end" parses "def foo; x { |a| a }; end" - says syntax error on "macro foo(\"\" y); end" says syntax error on "macro foo(\"\" y); end" - parses "module Foo(*T); end" parses "module Foo(*T); end" - parses "macro : Int32" parses "macro : Int32" - parses "else : Int32" parses "else : Int32" - parses "sizeof : Int32" parses "sizeof : Int32" - parses "foo(0, n << 2)" parses "foo(0, n << 2)" - parses "x.y=(1).to_s" parses "x.y=(1).to_s" - says syntax error on "a = 1; a += return" says syntax error on "a = 1; a += return" - parses "{% begin %}%i{ %s }{% end %}" parses "{% begin %}%i{ %s }{% end %}" - parses "%q{hello \\n world}" parses "%q{hello \\n world}" - parses "1 -\n2" parses "1 -\n2" - says syntax error on "return - 1" says syntax error on "return - 1" - says syntax error on "self, x = 1, 2" says syntax error on "self, x = 1, 2" - parses ":!=" parses ":!=" - parses "case {1}\nin {Int32}; 2; end" parses "case {1}\nin {Int32}; 2; end" - parses "a.b +=\n1" parses "a.b +=\n1" - parses "require : Int32" parses "require : Int32" - parses "def foo(@lib); end" parses "def foo(@lib); end" - says syntax error on "a, B = 1, 2" says syntax error on "a, B = 1, 2" - parses "def foo(x @pointerof); end" parses "def foo(x @pointerof); end" - parses "foo(0, n ^ 2)" parses "foo(0, n ^ 2)" - says syntax error on "foo(\"bar\" \"baz\")" says syntax error on "foo(\"bar\" \"baz\")" - says syntax error on "while return; end" says syntax error on "while return; end" - parses "property return : Int32" parses "property return : Int32" - parses "1.0_f32" parses "1.0_f32" - says syntax error on "next ** 1" says syntax error on "next ** 1" - parses "lib LibC; fun getchar(a : Int, b : Float) : Int; end" parses "lib LibC; fun getchar(a : Int, b : Float) : Int; end" - says syntax error on "return & 1" says syntax error on "return & 1" - says syntax error on "def foo(foo select); end" says syntax error on "def foo(foo select); end" - parses "foo(0, n >= 2)" parses "foo(0, n >= 2)" - parses "next : Int32" parses "next : Int32" - parses "def self.<; end;" parses "def self.<; end;" - parses "foo(n <= 2)" parses "foo(n <= 2)" - says syntax error on "def foo(asm); end" says syntax error on "def foo(asm); end" - parses "foo.*(1, 2) { 3 }" parses "foo.*(1, 2) { 3 }" - parses "def foo(@[Foo] var); end" parses "def foo(@[Foo] var); end" - parses "1 * -2" parses "1 * -2" - says syntax error on "def foo(private); end" says syntax error on "def foo(private); end" - parses "macro foo; 1 + 2 {{foo}} 3 + 4; end" parses "macro foo; 1 + 2 {{foo}} 3 + 4; end" - parses "->() { }" parses "->() { }" - parses "@a : Foo = 1" parses "@a : Foo = 1" - parses "{% begin %}%r|\\A|{% end %}" parses "{% begin %}%r|\\A|{% end %}" - says syntax error on "def foo :String\nend" says syntax error on "def foo :String\nend" - parses "{1 => 2 / 3}" parses "{1 => 2 / 3}" - parses "<<-SOME\n Sa\n Se\n SOME" parses "<<-SOME\n Sa\n Se\n SOME" - parses "*a, b = 1" parses "*a, b = 1" - parses "{% begin %}%x| %s |{% end %}" parses "{% begin %}%x| %s |{% end %}" - parses "abstract def foo\n1" parses "abstract def foo\n1" - parses "def ^(); end;" parses "def ^(); end;" - parses "/foo/m" parses "/foo/m" - parses "macro &-;end" parses "macro &-;end" - parses "foo %Q()" parses "foo %Q()" - parses "macro foo(@[Foo] *args);end" parses "macro foo(@[Foo] *args);end" - parses "1_i128" parses "1_i128" - says syntax error on "def foo() :String\nend" says syntax error on "def foo() :String\nend" - parses "foo(*{1})" parses "foo(*{1})" - parses "def foo(@pointerof); end" parses "def foo(@pointerof); end" - parses "foo.[]=" parses "foo.[]=" - says syntax error on "return / 1" says syntax error on "return / 1" - says syntax error on "class Foo(); end" says syntax error on "class Foo(); end" - parses "Foo(T?)" parses "Foo(T?)" - sets correct location of tuple type sets correct location of tuple type - parses "case 1\nin false; 2; end" parses "case 1\nin false; 2; end" - says syntax error on "def foo(var : Foo+); end" says syntax error on "def foo(var : Foo+); end" - says syntax error on "return == 1" says syntax error on "return == 1" - parses "alias Foo = Bar" parses "alias Foo = Bar" - says syntax error on "\"hello\" foo" says syntax error on "\"hello\" foo" - parses "def ===; end;" parses "def ===; end;" - parses "def foo(x @@false); end" parses "def foo(x @@false); end" - parses "def foo(&@block); end" parses "def foo(&@block); end" - parses "Foo(*T)" parses "Foo(*T)" - parses "def self.=~(); end;" parses "def self.=~(); end;" - parses "def foo(@@pointerof); end" parses "def foo(@@pointerof); end" - says syntax error on "break >= 1" says syntax error on "break >= 1" - says syntax error on "foo { |(instance_sizeof)| }" says syntax error on "foo { |(instance_sizeof)| }" - parses "foo[\nfoo[\n1\n]\n]" parses "foo[\nfoo[\n1\n]\n]" - parses "def foo(@@macro); end" parses "def foo(@@macro); end" - parses "->@foo.foo=" parses "->@foo.foo=" - parses "begin; 1; ensure; 2; end" parses "begin; 1; ensure; 2; end" - parses "def foo(var : self?); end" parses "def foo(var : self?); end" - parses "class Foo(T, *U); end" parses "class Foo(T, *U); end" - says syntax error on "@foo :: Foo" says syntax error on "@foo :: Foo" - parses "enum Foo; {% if 1 %}2{% end %}; end" parses "enum Foo; {% if 1 %}2{% end %}; end" - parses "{% begin %}%q[ %s ]{% end %}" parses "{% begin %}%q[ %s ]{% end %}" - parses "def foo(@@var); 1; end" parses "def foo(@@var); 1; end" - parses "Foo::Bar" parses "Foo::Bar" - parses "while true; end;" parses "while true; end;" - says syntax error on "foo { |(lib)| }" says syntax error on "foo { |(lib)| }" - parses "def foo(@out); end" parses "def foo(@out); end" - says syntax error on "case next; when 1; end; end" says syntax error on "case next; when 1; end; end" - parses "asm(\"nop\" : \"a\"(0) : \"b\"(1), \"c\"(2))" parses "asm(\"nop\" : \"a\"(0) : \"b\"(1), \"c\"(2))" - parses "macro foo(@[Foo] outer inner);end" parses "macro foo(@[Foo] outer inner);end" - parses "def foo(extend foo); end" parses "def foo(extend foo); end" - parses "macro &+;end" parses "macro &+;end" - parses "macro foo\n\"\\\\\"\nend" parses "macro foo\n\"\\\\\"\nend" - parses "lib LibC; fun foo : Int**; end" parses "lib LibC; fun foo : Int**; end" - parses "asm(\"nop\" : \"a\"(0))" parses "asm(\"nop\" : \"a\"(0))" - parses "def self.~(); end;" parses "def self.~(); end;" - says syntax error on "foo[1] = return" says syntax error on "foo[1] = return" - parses "foo(n - 2)" parses "foo(n - 2)" - parses "return *1" parses "return *1" - parses "def foo(@@protected); end" parses "def foo(@@protected); end" - says syntax error on "x { |*a, *b| }" says syntax error on "x { |*a, *b| }" - parses "\"foo\#{bar}baz\"" parses "\"foo\#{bar}baz\"" - parses "foo(n > 2)" parses "foo(n > 2)" - parses "lib LibC\nend" parses "lib LibC\nend" - parses "{A: 1, B: 2}" parses "{A: 1, B: 2}" - says syntax error on "a {} = 1" says syntax error on "a {} = 1" - parses "case 1; when x then 2; else; 3; end" parses "case 1; when x then 2; else; 3; end" - parses "{% begin %}%r(\\A){% end %}" parses "{% begin %}%r(\\A){% end %}" - parses "foo x do\n//\nend" parses "foo x do\n//\nend" - parses "def foo(a); a; end" parses "def foo(a); a; end" - parses "foo &.each do\nend" parses "foo &.each do\nend" - parses "foo = 1; ->foo.//(Int32)" parses "foo = 1; ->foo.//(Int32)" - parses "n % 2" parses "n % 2" - parses "def foo(x @macro); end" parses "def foo(x @macro); end" - parses "1.[]?(2)" parses "1.[]?(2)" - says syntax error on "foo { |pointerof| }" says syntax error on "foo { |pointerof| }" - says syntax error on "def foo(instance_sizeof); end" says syntax error on "def foo(instance_sizeof); end" - parses "foo +1_i64" parses "foo +1_i64" - says syntax error on "foo { |(abstract)| }" says syntax error on "foo { |(abstract)| }" - parses "lib LibC; Foo = 1; end" parses "lib LibC; Foo = 1; end" - parses "foo(n &+ 2)" parses "foo(n &+ 2)" - sets correct location of annotation on method parameter sets correct location of annotation on method parameter - parses ":~" parses ":~" - says syntax error on "next < 1" says syntax error on "next < 1" - parses "def foo(struct foo); end" parses "def foo(struct foo); end" - parses "1..;" parses "1..;" - says syntax error on "\n lib LibFoo\n fun foo(x : Int32\n y : Float64)\n end\n " says syntax error on "\n lib LibFoo\n fun foo(x : Int32\n y : Float64)\n end\n " - parses "nil" parses "nil" - parses "break 1" parses "break 1" - parses ":[]=" parses ":[]=" - parses "lib LibC\nfun getchar\nend" parses "lib LibC\nfun getchar\nend" - parses "def foo(in foo); end" parses "def foo(in foo); end" - parses "def foo(x @end); end" parses "def foo(x @end); end" - parses "->(x : Int32) { x }" parses "->(x : Int32) { x }" - parses "foo(z: 0, a: n &* 2)" parses "foo(z: 0, a: n &* 2)" - parses "/\\//" parses "/\\//" - parses "Foo({x: X, y: Y})" parses "Foo({x: X, y: Y})" - parses "{[] of Foo, Bar::Baz ** 2}" parses "{[] of Foo, Bar::Baz ** 2}" - parses "x, y = <<-FOO, <<-BAR\nhello\nFOO\nworld\nBAR" parses "x, y = <<-FOO, <<-BAR\nhello\nFOO\nworld\nBAR" - parses "def foo(private foo); end" parses "def foo(private foo); end" - parses "Foo({->})" parses "Foo({->})" - parses "Foo(\nT\n)" parses "Foo(\nT\n)" - says syntax error on "def foo(end); end" says syntax error on "def foo(end); end" - parses "def foo(lib foo); end" parses "def foo(lib foo); end" - says syntax error on "def foo(foo pointerof); end" says syntax error on "def foo(foo pointerof); end" - says syntax error on "foo { |out| }" says syntax error on "foo { |out| }" - says syntax error on "if 1 == 1 a; end" says syntax error on "if 1 == 1 a; end" - parses "def foo(if foo); end" parses "def foo(if foo); end" - parses "a\nwhile / /; / /; end" parses "a\nwhile / /; / /; end" - parses "def self.foo=()\n1\nend" parses "def self.foo=()\n1\nend" - parses "foo.<(1, 2)" parses "foo.<(1, 2)" - says syntax error on "until break; end" says syntax error on "until break; end" - parses "a = 1; a &-=\n1" parses "a = 1; a &-=\n1" - parses "def foo(break foo); end" parses "def foo(break foo); end" - parses "foo(z: 0, a: n + 2)" parses "foo(z: 0, a: n + 2)" - parses "yield" parses "yield" - parses "def foo(var : (Int, Float) -> Double); end" parses "def foo(var : (Int, Float) -> Double); end" - parses "def foo(until foo); end" parses "def foo(until foo); end" - parses "foo./ do end" parses "foo./ do end" - parses "def >=(other, file = 1); end" parses "def >=(other, file = 1); end" - says syntax error on "foo { |(private)| }" says syntax error on "foo { |(private)| }" - parses "lib LibC; enum Foo; A\nB; C\nD = 1; end end" parses "lib LibC; enum Foo; A\nB; C\nD = 1; end end" - says syntax error on "foo { |(typeof)| }" says syntax error on "foo { |(typeof)| }" - parses "begin; 1; rescue Foo | Bar; 2; end" parses "begin; 1; rescue Foo | Bar; 2; end" - parses ":foo" parses ":foo" - says syntax error on "foo x: 1, x: 1" says syntax error on "foo x: 1, x: 1" - parses "def foo(@@typeof); end" parses "def foo(@@typeof); end" - parses "f.x //= 2" parses "f.x //= 2" - parses "foo.bar=(*baz)" parses "foo.bar=(*baz)" - parses "module Foo; end" parses "module Foo; end" - parses "foo./ 1, 2" parses "foo./ 1, 2" - parses "property nil : Int32" parses "property nil : Int32" - parses "2.3_f32" parses "2.3_f32" - says syntax error on "next == 1" says syntax error on "next == 1" - says syntax error on "foo { |end| }" says syntax error on "foo { |end| }" - says syntax error on "def foo(x : U) forall U, U; end" says syntax error on "def foo(x : U) forall U, U; end" - says syntax error on "'''" says syntax error on "'''" - parses "property do : Int32" parses "property do : Int32" - parses "def `(cmd); 1; end" parses "def `(cmd); 1; end" - parses "Foo(typeof(1), typeof(2))" parses "Foo(typeof(1), typeof(2))" - parses "x[1, ..2]" parses "x[1, ..2]" - says syntax error on "\"foo\" \"bar\"" says syntax error on "\"foo\" \"bar\"" - parses "a = 1; a //=\n1" parses "a = 1; a //=\n1" - parses "def foo(@@sizeof); end" parses "def foo(@@sizeof); end" - parses "a = 1; a += 10 if a += 20" parses "a = 1; a += 10 if a += 20" - parses "my_def def foo\nloop do\nend\nend" parses "my_def def foo\nloop do\nend\nend" - parses "begin; 1; rescue ::Foo | ::Bar; 2; end" parses "begin; 1; rescue ::Foo | ::Bar; 2; end" - parses "lib LibC\nalias Foo = Bar\nend" parses "lib LibC\nalias Foo = Bar\nend" - parses "(bar do\nend)" parses "(bar do\nend)" - parses "def self.!~(); end;" parses "def self.!~(); end;" - parses "1 + 2" parses "1 + 2" - parses "Foo(\"foo bar\": U)" parses "Foo(\"foo bar\": U)" - parses "->Foo.&**(Int32)" parses "->Foo.&**(Int32)" - parses "foo = 1; foo(-1)" parses "foo = 1; foo(-1)" - parses "def foo(@class); end" parses "def foo(@class); end" - parses "enum Foo; {{1}}; end" parses "enum Foo; {{1}}; end" - parses "ensure : Int32" parses "ensure : Int32" - parses "/(fo\#{\"bar\"}\#{1}o)/" parses "/(fo\#{\"bar\"}\#{1}o)/" - parses "def foo(x @@module); end" parses "def foo(x @@module); end" - parses "foo(0, n <= 2)" parses "foo(0, n <= 2)" - says syntax error on "+next" says syntax error on "+next" - parses "foo.^ 1, 2" parses "foo.^ 1, 2" - says syntax error on "def foo(foo break); end" says syntax error on "def foo(foo break); end" - parses "def foo(a, b = a); end" parses "def foo(a, b = a); end" - parses "Foo({x: X})" parses "Foo({x: X})" - parses ":<<" parses ":<<" - says syntax error on "foo { |private| }" says syntax error on "foo { |private| }" - says syntax error on "foo { |(until)| }" says syntax error on "foo { |(until)| }" - says syntax error on "foo { |struct| }" says syntax error on "foo { |struct| }" - parses "Foo(X, instance_alignof(Int32))" parses "Foo(X, instance_alignof(Int32))" - parses "foo(a: n &* 2)" parses "foo(a: n &* 2)" - parses "begin; 1; rescue; 2; end" parses "begin; 1; rescue; 2; end" - parses "a = 1; b = 2; c = 3; a-b-c" parses "a = 1; b = 2; c = 3; a-b-c" - parses "instance_alignof(X)" parses "instance_alignof(X)" - parses "{% begin %}%q{ %s }{% end %}" parses "{% begin %}%q{ %s }{% end %}" - parses "case \nwhen 1\n2\nend" parses "case \nwhen 1\n2\nend" - parses "lib LibC; struct Foo; x : Int**; end end" parses "lib LibC; struct Foo; x : Int**; end end" - parses "{% begin %}%w| %s |{% end %}" parses "{% begin %}%w| %s |{% end %}" - says syntax error on "macro Foo;end" says syntax error on "macro Foo;end" - parses "1 - 2" parses "1 - 2" - parses "x([] of Foo, Bar.new)" parses "x([] of Foo, Bar.new)" - says syntax error on "foo { |def| }" says syntax error on "foo { |def| }" - parses "foo.% 1, 2" parses "foo.% 1, 2" - parses "foo.<= do end" parses "foo.<= do end" - parses "def foo(var : Int | Double); end" parses "def foo(var : Int | Double); end" - parses "begin; 1; 2; 3; end;" parses "begin; 1; 2; 3; end;" - parses "macro foo=;end" parses "macro foo=;end" - says syntax error on "next ^ 1" says syntax error on "next ^ 1" - says syntax error on "foo :: Foo" says syntax error on "foo :: Foo" - parses "foo.> do end" parses "foo.> do end" - parses "foo(n !~ 2)" parses "foo(n !~ 2)" - says syntax error on "macro foo.bar;end" says syntax error on "macro foo.bar;end" - parses "->Foo.-(Int32)" parses "->Foo.-(Int32)" - parses "def foo(x, *args, y = 2, w, z = 3); 1; end" parses "def foo(x, *args, y = 2, w, z = 3); 1; end" - says syntax error on "case return; when 1; end; end" says syntax error on "case return; when 1; end; end" - says syntax error on "def foo(foo typeof); end" says syntax error on "def foo(foo typeof); end" - parses "a = 1; a/b" parses "a = 1; a/b" - says syntax error on "def foo(false); end" says syntax error on "def foo(false); end" - parses "1 =~ 2" parses "1 =~ 2" - parses "`foo`" parses "`foo`" - parses "def <(); end;" parses "def <(); end;" - parses "1 unless 3" parses "1 unless 3" - parses "b.c &&= 1" parses "b.c &&= 1" - parses "*a.foo, a.bar = 1" parses "*a.foo, a.bar = 1" - parses "[] of {String, ->}" parses "[] of {String, ->}" - parses "def foo(@@struct); end" parses "def foo(@@struct); end" - parses "<<-FOO\n \t1\n \tFOO" parses "<<-FOO\n \t1\n \tFOO" - says syntax error on "def foo(foo include); end" says syntax error on "def foo(foo include); end" - parses "next if true" parses "next if true" - parses "def foo(x @@select); end" parses "def foo(x @@select); end" - parses "foo(&.!)" parses "foo(&.!)" - parses "def ===(); end;" parses "def ===(); end;" - parses "macro foo(@[Foo] **args);end" parses "macro foo(@[Foo] **args);end" - parses "macro foo;bar{% for x in y %}body{% end %}baz;end" parses "macro foo;bar{% for x in y %}body{% end %}baz;end" - parses "{1 =>\n2, 3 =>\n4}" parses "{1 =>\n2, 3 =>\n4}" - says syntax error on "case 1; when break; end; end" says syntax error on "case 1; when break; end; end" - says syntax error on "next &* 1" says syntax error on "next &* 1" - parses "def foo(x : U) forall T, U; end" parses "def foo(x : U) forall T, U; end" - says syntax error on "a = 1; a += next" says syntax error on "a = 1; a += next" - parses "def foo(self foo); end" parses "def foo(self foo); end" - says syntax error on "{% unless 1; 2; elsif 3; 4; end %}" says syntax error on "{% unless 1; 2; elsif 3; 4; end %}" - parses "var.@foo" parses "var.@foo" - parses "foo 1;" parses "foo 1;" - parses "foo.&(1, 2) { 3 }" parses "foo.&(1, 2) { 3 }" - says syntax error on "case 1\nin .nil?; 2" says syntax error on "case 1\nin .nil?; 2" - parses "foo(z: 0, a: n ** 2)" parses "foo(z: 0, a: n ** 2)" - parses "def []; end" parses "def []; end" - parses "macro foo(x = __LINE__);end" parses "macro foo(x = __LINE__);end" - parses "a = 1; a &-= 1" parses "a = 1; a &-= 1" - says syntax error on "FOO, BAR = 1, 2" says syntax error on "FOO, BAR = 1, 2" - parses "{{a = 1 if 2}}" parses "{{a = 1 if 2}}" - parses "[\n1\n]" parses "[\n1\n]" - parses "a ? 1\n : b ? 2\n : c ? 3\n : 0" parses "a ? 1\n : b ? 2\n : c ? 3\n : 0" - parses "def !~; end;" parses "def !~; end;" - says syntax error on "foo { |true| }" says syntax error on "foo { |true| }" - parses "{% begin %}%i< %s >{% end %}" parses "{% begin %}%i< %s >{% end %}" - parses "def self.-(); end;" parses "def self.-(); end;" - parses "/foo/imximx" parses "/foo/imximx" - parses "def ==; end;" parses "def ==; end;" - parses "foo = 1; ->foo.|(Int32)" parses "foo = 1; ->foo.|(Int32)" - parses "def foo(x @@typeof); end" parses "def foo(x @@typeof); end" - parses "Int[]" parses "Int[]" - says syntax error on "yield next" says syntax error on "yield next" - parses "a.b -=\n1" parses "a.b -=\n1" - parses "def foo(@@def); end" parses "def foo(@@def); end" - parses "foo.Bar" parses "foo.Bar" - parses "def foo(@require); end" parses "def foo(@require); end" - parses "f.x &*= 2" parses "f.x &*= 2" - parses "def foo(x @if); end" parses "def foo(x @if); end" - parses ":\"foo\"" parses ":\"foo\"" - says syntax error on "foo(1, 2, 3 end" says syntax error on "foo(1, 2, 3 end" - parses "def ==(); end;" parses "def ==(); end;" - parses "a = 1; a &+=\n1" parses "a = 1; a &+=\n1" - says syntax error on "foo { |(nil)| }" says syntax error on "foo { |(nil)| }" - parses "a.b &+=\n1" parses "a.b &+=\n1" - says syntax error on "class Foo(*T, *U); end" says syntax error on "class Foo(*T, *U); end" - parses "__DIR__" parses "__DIR__" - parses "{A::B}" parses "{A::B}" - parses "foo -1.0, -2.0" parses "foo -1.0, -2.0" - parses "1 rescue 2 if 3" parses "1 rescue 2 if 3" - says syntax error on "case 1; when next; end; end" says syntax error on "case 1; when next; end; end" - says syntax error on "macro foo&&;end" says syntax error on "macro foo&&;end" - parses "nil?( )" parses "nil?( )" - says syntax error on "next * 1" says syntax error on "next * 1" - says syntax error on "next & 1" says syntax error on "next & 1" - parses "enum : Int32" parses "enum : Int32" - parses "begin\n1\nend\nif true; end" parses "begin\n1\nend\nif true; end" - parses "{..2}" parses "{..2}" - parses "a; if / /\n/ /\nelsif / /\n/ /\nend" parses "a; if / /\n/ /\nelsif / /\n/ /\nend" - parses "...2" parses "...2" - parses "a.b &*=\n1" parses "a.b &*=\n1" - parses "require \"foo\"; [1]" parses "require \"foo\"; [1]" - parses "foo[*baz] = 1" parses "foo[*baz] = 1" - says syntax error on "1 2" says syntax error on "1 2" - parses "case;when true;1;end" parses "case;when true;1;end" - parses "def foo(@instance_sizeof); end" parses "def foo(@instance_sizeof); end" - parses "macro foo;unless var;true;end;end" parses "macro foo;unless var;true;end;end" - parses "break 1 if true" parses "break 1 if true" - parses "foo%w" parses "foo%w" - parses "def foo(x @@sizeof); end" parses "def foo(x @@sizeof); end" - says syntax error on "def foo(foo alias); end" says syntax error on "def foo(foo alias); end" - parses "self / number" parses "self / number" - parses "def foo(false foo); end" parses "def foo(false foo); end" - parses "foo(1, **bar, &block)" parses "foo(1, **bar, &block)" - parses "lib LibC\n$errno = Foo : Int32\nend" parses "lib LibC\n$errno = Foo : Int32\nend" - says syntax error on "a() += 1" says syntax error on "a() += 1" - parses "property while : Int32" parses "property while : Int32" - parses "while true; end\nif true; end" parses "while true; end\nif true; end" - parses ":==" parses ":==" - parses "..2" parses "..2" - parses "foo %r" parses "foo %r" - parses "include Foo\nif true; end" parses "include Foo\nif true; end" - parses "a { |x| x } / b" parses "a { |x| x } / b" - parses "def self./; end;" parses "def self./; end;" - parses "def foo(@var); end" parses "def foo(@var); end" - says syntax error on "def foo(foo abstract); end" says syntax error on "def foo(foo abstract); end" - parses "lib LibC; struct Foo; {{ 1 }}; end; end" parses "lib LibC; struct Foo; {{ 1 }}; end; end" - says syntax error on "foo { |(include)| }" says syntax error on "foo { |(include)| }" - parses "<<-HERE\r\n One\r\n Zero\r\n HERE\r\n" parses "<<-HERE\r\n One\r\n Zero\r\n HERE\r\n" - parses "def foo(@@with); end" parses "def foo(@@with); end" - says syntax error on "def !; end" says syntax error on "def !; end" - parses "true : Int32" parses "true : Int32" - parses "1 % 2" parses "1 % 2" - parses "foo.===(1, 2)" parses "foo.===(1, 2)" - parses "foo(1)" parses "foo(1)" - parses "macro foo\n <<-FOO\n %foo\n FOO\nend" parses "macro foo\n <<-FOO\n %foo\n FOO\nend" - says syntax error on "return % 1" says syntax error on "return % 1" - says syntax error on "def foo(\"bar \#{1} qux\" y); y; end" says syntax error on "def foo(\"bar \#{1} qux\" y); y; end" - parses "foo 1\n" parses "foo 1\n" - single splats inside container literals - says syntax error on "case {*1}\nwhen {2}; 3; end" says syntax error on "case {*1}\nwhen {2}; 3; end" - parses "Set {*{1} * 2}" parses "Set {*{1} * 2}" - parses "[*[*[1]], *[2]]" parses "[*[*[1]], *[2]]" - parses "{1, *2}" parses "{1, *2}" - parses "case 1\nwhen {*2}; 3; end" parses "case 1\nwhen {*2}; 3; end" - parses "[*1, 2]" parses "[*1, 2]" - parses "x = {*1}" parses "x = {*1}" - says syntax error on "{1 => 2, *3}" says syntax error on "{1 => 2, *3}" - parses "{*1, 2}" parses "{*1, 2}" - says syntax error on "{*1 => 2}" says syntax error on "{*1 => 2}" - parses "{*1 * 2}" parses "{*1 * 2}" - parses "{1, *2, 3, *4, 5}" parses "{1, *2, 3, *4, 5}" - parses "[1, *2, 3, *4, 5]" parses "[1, *2, 3, *4, 5]" - parses "Set {*1, 2, *3}" parses "Set {*1, 2, *3}" - parses "{*1, *2}" parses "{*1, *2}" - parses "[*1, *2]" parses "[*1, *2]" - says syntax error on "{a: 1, *2}" says syntax error on "{a: 1, *2}" - parses "[*1]" parses "[*1]" - says syntax error on "case {1}\nwhen {*2}; 3; end" says syntax error on "case {1}\nwhen {*2}; 3; end" - says syntax error on "{*a: 1}" says syntax error on "{*a: 1}" - parses "{*1}" parses "{*1}" - parses "[1, *2]" parses "[1, *2]" - parses "[*1 ** 2]" parses "[*1 ** 2]" - says syntax error on "{a[0]: 1}" says syntax error on "{a[0]: 1}" - says syntax error on "macro !;end" says syntax error on "macro !;end" - parses "n > 2" parses "n > 2" - parses "def self.&; end;" parses "def self.&; end;" - parses "property elsif : Int32" parses "property elsif : Int32" - parses "foo./(1, 2)" parses "foo./(1, 2)" - says syntax error on "a.[]() = 1" says syntax error on "a.[]() = 1" - parses "def foo; a = 1; x { a }; end" parses "def foo; a = 1; x { a }; end" - parses "def foo(x @@unless); end" parses "def foo(x @@unless); end" - parses "foo &.block(1)" parses "foo &.block(1)" - parses "def foo(@enum); end" parses "def foo(@enum); end" - parses "property module : Int32" parses "property module : Int32" - parses "a = 1; a &*= 1" parses "a = 1; a &*= 1" - parses "def foo(@return); end" parses "def foo(@return); end" - parses "x = 1; foo x do\nend" parses "x = 1; foo x do\nend" - parses "foo.bar(1, 2) { 3 }" parses "foo.bar(1, 2) { 3 }" - parses "foo(0, n + 2)" parses "foo(0, n + 2)" - parses "def foo(with foo); end" parses "def foo(with foo); end" - says syntax error on "1 unless return" says syntax error on "1 unless return" - parses "break 1, 2" parses "break 1, 2" - says syntax error on "next > 1" says syntax error on "next > 1" - parses "puts %w{one two}" parses "puts %w{one two}" - parses "foo.>= 1, 2" parses "foo.>= 1, 2" - parses "foo.!~(1, 2) { 3 }" parses "foo.!~(1, 2) { 3 }" - parses "def self.[]?; end" parses "def self.[]?; end" - parses "1.[]=(2, 3)" parses "1.[]=(2, 3)" - parses "1..\n2.." parses "1..\n2.." - parses "1" parses "1" - parses "foo[0] = 1" parses "foo[0] = 1" - parses "def %(); end" parses "def %(); end" - parses "def self.foo()\n1\nend" parses "def self.foo()\n1\nend" - says syntax error on "foo.||" says syntax error on "foo.||" - says syntax error on "foo { |(x, x)| }" says syntax error on "foo { |(x, x)| }" - parses "macro =~;end" parses "macro =~;end" - parses "lib Foo::Bar\nend" parses "lib Foo::Bar\nend" - parses "foo +1.0" parses "foo +1.0" - says syntax error on "Set {1, 2, 3} of Int32" says syntax error on "Set {1, 2, 3} of Int32" - parses "def foo(@@abstract); end" parses "def foo(@@abstract); end" - parses "macro foo\n <<-FOO, <<-BAR + \"\"\n FOO\n BAR\nend" parses "macro foo\n <<-FOO, <<-BAR + \"\"\n FOO\n BAR\nend" - parses "macro foo;%var if true;end" parses "macro foo;%var if true;end" - parses "qux \"foo\#{bar do end}baz\"" parses "qux \"foo\#{bar do end}baz\"" - parses "{{ foo.nil? }}" parses "{{ foo.nil? }}" - parses "enum Foo; A = 1; B; end" parses "enum Foo; A = 1; B; end" - parses "def foo; with a yield; end" parses "def foo; with a yield; end" - parses "1 - 2" parses "1 - 2" - parses "return : Int32" parses "return : Int32" - parses "typeof(\n 1\n)" parses "typeof(\n 1\n)" - parses "- 1" parses "- 1" - parses "f.x &+= 2" parses "f.x &+= 2" - says syntax error on "macro foo; {% foo = 1 }; end" says syntax error on "macro foo; {% foo = 1 }; end" - says syntax error on "macro foo x\n 1 + 2; end" says syntax error on "macro foo x\n 1 + 2; end" - says syntax error on "def foo(x x); 1; end" says syntax error on "def foo(x x); 1; end" - parses "foo(0, n === 2)" parses "foo(0, n === 2)" - parses "foo(n == 2)" parses "foo(n == 2)" - parses "f.x /= 2" parses "f.x /= 2" - parses "def Foo::Bar.foo\n1\nend" parses "def Foo::Bar.foo\n1\nend" - parses "def foo; yield 1; end" parses "def foo; yield 1; end" - says syntax error on " {1 => end" says syntax error on " {1 => end" - parses "n &+ 2" parses "n &+ 2" - parses "@[Foo(\n1, foo: 2\n)]" parses "@[Foo(\n1, foo: 2\n)]" - parses "foo do; 1; end" parses "foo do; 1; end" - parses "def ===(*args, **opts); end" parses "def ===(*args, **opts); end" - parses "foo = 1; ->foo.%(Int32)" parses "foo = 1; ->foo.%(Int32)" - parses "break : Int32" parses "break : Int32" - parses "foo(a: n ** 2)" parses "foo(a: n ** 2)" - parses "foo.!~ do end" parses "foo.!~ do end" - parses "{\"\".id}" parses "{\"\".id}" - parses "def foo; a = 1; with a yield a; end" parses "def foo; a = 1; with a yield a; end" - says syntax error on "def foo(foo enum); end" says syntax error on "def foo(foo enum); end" - parses "foo(0, n > 2)" parses "foo(0, n > 2)" - parses ":&**" parses ":&**" - parses "{% if x %}body{% end %}" parses "{% if x %}body{% end %}" - says syntax error on "select\nwhen 1\n2\nend" says syntax error on "select\nwhen 1\n2\nend" - parses "def foo(@[Foo] outer inner); end" parses "def foo(@[Foo] outer inner); end" - parses "pointerof(\n foo\n)" parses "pointerof(\n foo\n)" - parses "/foo/i" parses "/foo/i" - parses ":+" parses ":+" - parses "def /(); end;" parses "def /(); end;" - parses "def []=(other, file = 1); end" parses "def []=(other, file = 1); end" - parses "Foo(X, alignof(Int32))" parses "Foo(X, alignof(Int32))" - parses "foo(1, **bar)" parses "foo(1, **bar)" - parses "foo = 1; ->foo.===(Int32)" parses "foo = 1; ->foo.===(Int32)" - parses "{% begin %}%x{ %s }{% end %}" parses "{% begin %}%x{ %s }{% end %}" - parses "alignof(\n Int32\n)" parses "alignof(\n Int32\n)" - parses "-> do; 1; rescue; 2; end" parses "-> do; 1; rescue; 2; end" - parses "*_ = 1, 2" parses "*_ = 1, 2" - says syntax error on "x--" says syntax error on "x--" - parses "with : Int32" parses "with : Int32" - parses "def foo(asm foo); end" parses "def foo(asm foo); end" - parses "a = uninitialized Foo; a" parses "a = uninitialized Foo; a" - parses "next {1 => 2}" parses "next {1 => 2}" - parses "1.foo do; 1; end" parses "1.foo do; 1; end" - says syntax error on "a, b, *c, d = 1, 2" says syntax error on "a, b, *c, d = 1, 2" - parses "def foo(x @instance_sizeof); end" parses "def foo(x @instance_sizeof); end" - parses "foo(&.is_a?(T))" parses "foo(&.is_a?(T))" - parses "lib LibC\nfun getchar(...)\nend" parses "lib LibC\nfun getchar(...)\nend" - parses "@@a = uninitialized Foo" parses "@@a = uninitialized Foo" - parses "def foo(@include); end" parses "def foo(@include); end" - parses "foo.is_a?(Const)" parses "foo.is_a?(Const)" - parses "{% begin %}%w{ %s }{% end %}" parses "{% begin %}%w{ %s }{% end %}" - parses "macro foo; 1 + 2 {{foo}}\\ 3 + 4; end" parses "macro foo; 1 + 2 {{foo}}\\ 3 + 4; end" - parses "foo { |(_, c)| c }" parses "foo { |(_, c)| c }" - parses "&+ 1" parses "&+ 1" - parses "->Foo.&+(Int32)" parses "->Foo.&+(Int32)" - parses "foo(z: 0, a: n !~ 2)" parses "foo(z: 0, a: n !~ 2)" - parses "foo(0, n &+ 2)" parses "foo(0, n &+ 2)" - parses "case\nend" parses "case\nend" - says syntax error on "until return; end" says syntax error on "until return; end" - says syntax error on "asm(\"nop\" ::: \"\#{foo}\")" says syntax error on "asm(\"nop\" ::: \"\#{foo}\")" - parses "+1.0_f32" parses "+1.0_f32" - parses "case when 1\n2\nend" parses "case when 1\n2\nend" - says syntax error on "<<-HERE\n One\n \#{1}\n HERE" says syntax error on "<<-HERE\n One\n \#{1}\n HERE" - parses "return 1.bar do\nend" parses "return 1.bar do\nend" - sets correct location of global path in class def sets correct location of global path in class def - parses "def foo(x @return); end" parses "def foo(x @return); end" - says syntax error on "*a, b, c, d = 1, 2" says syntax error on "*a, b, c, d = 1, 2" - parses "1.as?(\n Int32\n)" parses "1.as?(\n Int32\n)" - parses ":foo" parses ":foo" - parses "foo[*baz]" parses "foo[*baz]" - parses "macro foo;{% verbatim do %}1{% foo %}2{% end %};end" parses "macro foo;{% verbatim do %}1{% foo %}2{% end %};end" - says syntax error on "foo { |include| }" says syntax error on "foo { |include| }" - says syntax error on "a.b, c.d() = 1" says syntax error on "a.b, c.d() = 1" - parses "Foo(\"foo\": U, \"bar\": V)" parses "Foo(\"foo\": U, \"bar\": V)" - parses "foo %w()" parses "foo %w()" - parses "1 ? 2 : 3" parses "1 ? 2 : 3" - parses "1.0" parses "1.0" - parses "a = 1; a //= 1" parses "a = 1; a //= 1" - parses "foo &.baz.qux do\nend" parses "foo &.baz.qux do\nend" - parses "{a: 1}" parses "{a: 1}" - says syntax error on "macro foo;{%end};end" says syntax error on "macro foo;{%end};end" - says syntax error on "foo(foo(&.block)" says syntax error on "foo(foo(&.block)" - says syntax error on "return .. 1" says syntax error on "return .. 1" - parses "1 | 2" parses "1 | 2" - parses "foo = 1; foo +1" parses "foo = 1; foo +1" - says syntax error on "foo { |(select)| }" says syntax error on "foo { |(select)| }" - parses "foo(out @x); @x" parses "foo(out @x); @x" - parses "def foo(x @@next); end" parses "def foo(x @@next); end" - parses "->(x) { x }" parses "->(x) { x }" - parses "foo(0, n ** 2)" parses "foo(0, n ** 2)" - parses "Foo(X, sizeof(Int32))" parses "Foo(X, sizeof(Int32))" - parses "foo.**(1, 2)" parses "foo.**(1, 2)" - parses "def foo(x @nil); end" parses "def foo(x @nil); end" - parses "select\nwhen foo\n2\nwhen bar\n4\nend" parses "select\nwhen foo\n2\nwhen bar\n4\nend" - parses "f.x += 2" parses "f.x += 2" - parses "@[Foo]" parses "@[Foo]" - parses "case {1}\nin {.bar?}; 2; end" parses "case {1}\nin {.bar?}; 2; end" - parses "def foo(bar = 1\n); 2; end" parses "def foo(bar = 1\n); 2; end" - says syntax error on "break <= 1" says syntax error on "break <= 1" - says syntax error on "def foo(nil); end" says syntax error on "def foo(nil); end" - parses "def foo(@@in); end" parses "def foo(@@in); end" - parses "until : Int32" parses "until : Int32" - parses "def foo(@[Foo] &@block); end" parses "def foo(@[Foo] &@block); end" - parses "def foo(a, &block : Foo); end" parses "def foo(a, &block : Foo); end" - parses ":>" parses ":>" - parses "a = 1; a &=\n1" parses "a = 1; a &=\n1" - parses "foo(a: n | 2)" parses "foo(a: n | 2)" - parses "@[Foo(\"hello\")]" parses "@[Foo(\"hello\")]" - parses "def foo; x { |a, *b| b }; end" parses "def foo; x { |a, *b| b }; end" - parses "_ = 1" parses "_ = 1" - parses "{1 => 2, 3 => 4}" parses "{1 => 2, 3 => 4}" - says syntax error on "{\"\": 1}" says syntax error on "{\"\": 1}" - parses "def foo(@@private); end" parses "def foo(@@private); end" - parses "foo { |a| 1 }" parses "foo { |a| 1 }" - parses "macro ^;end" parses "macro ^;end" - parses "->foo=" parses "->foo=" - parses "1.nil?(\n)" parses "1.nil?(\n)" - parses "begin; 1; end;" parses "begin; 1; end;" - says syntax error on "next + 1" says syntax error on "next + 1" - parses "break;" parses "break;" - parses "foo !false" parses "foo !false" - parses "module Foo(T); end" parses "module Foo(T); end" - says syntax error on "class Foo(T U)" says syntax error on "class Foo(T U)" - parses "property with : Int32" parses "property with : Int32" - parses "def foo(var : self); end" parses "def foo(var : self); end" - parses "is_a?(Const)" parses "is_a?(Const)" - parses "def foo(var : Int?); end" parses "def foo(var : Int?); end" - says syntax error on "foo { |(begin)| }" says syntax error on "foo { |(begin)| }" - parses "foo(n ^ 2)" parses "foo(n ^ 2)" - parses "lib LibC; {% if 1 %}2{% end %}; end" parses "lib LibC; {% if 1 %}2{% end %}; end" - parses "def foo(require foo); end" parses "def foo(require foo); end" - parses "def foo(@until); end" parses "def foo(@until); end" - parses "a, b = 1" parses "a, b = 1" - parses "a = 1; a[2] &&= 3" parses "a = 1; a[2] &&= 3" - parses "2 * 3 + 4 * 5" parses "2 * 3 + 4 * 5" - parses "foo = 1; ->foo.foo" parses "foo = 1; ->foo.foo" - parses "a.foo &block" parses "a.foo &block" - parses "return 1" parses "return 1" - says syntax error on "unless break; end" says syntax error on "unless break; end" - parses "foo(1, a: 1, b: 2)" parses "foo(1, a: 1, b: 2)" - says syntax error on "foo(next)" says syntax error on "foo(next)" - parses "1.as? Bar" parses "1.as? Bar" - parses "macro **;end" parses "macro **;end" - says syntax error on "{1, ->{ |_| x } }" says syntax error on "{1, ->{ |_| x } }" - parses "foo(z: 0, a: n &** 2)" parses "foo(z: 0, a: n &** 2)" - parses "def [](x); end" parses "def [](x); end" - parses "foo rescue 2" parses "foo rescue 2" - parses "a = 1; a |= 1" parses "a = 1; a |= 1" - parses "foo &.%(1)" parses "foo &.%(1)" - says syntax error on "def nil?; end" says syntax error on "def nil?; end" - parses "def <; end;" parses "def <; end;" - parses "extend Foo" parses "extend Foo" - says syntax error on "a.b(), c.d = 1" says syntax error on "a.b(), c.d = 1" - says syntax error on "A = begin; 1; rescue; 1; else; B = 1; end" says syntax error on "A = begin; 1; rescue; 1; else; B = 1; end" - says syntax error on "break.foo" says syntax error on "break.foo" - parses "->(x : Int32) { }" parses "->(x : Int32) { }" - says syntax error on "case 1\nin _;" says syntax error on "case 1\nin _;" - parses "def foo(@false); end" parses "def foo(@false); end" - parses "a.foo(&block)" parses "a.foo(&block)" - says syntax error on "macro responds_to?; end" says syntax error on "macro responds_to?; end" - parses "as?(Bar)" parses "as?(Bar)" - parses "{\"foo\": 1, \"bar\": 2}" parses "{\"foo\": 1, \"bar\": 2}" - parses "def foo(x @@include); end" parses "def foo(x @@include); end" - parses "property def : Int32" parses "property def : Int32" - parses "-1" parses "-1" - parses "puts ~1" parses "puts ~1" - parses "<<-HERE1; <<-HERE2\nHERE1\nhere2\nHERE2" parses "<<-HERE1; <<-HERE2\nHERE1\nhere2\nHERE2" - says syntax error on "lib Foo; fun foo(x : Int32, x : Int64); end" says syntax error on "lib Foo; fun foo(x : Int32, x : Int64); end" - parses "foo { |(a, *b, c)| }" parses "foo { |(a, *b, c)| }" - parses "if foo; 1; end" parses "if foo; 1; end" - parses "@a : Foo | Int32" parses "@a : Foo | Int32" - parses "lib LibC\nfun getch = \"get.char\"(x : Int32)\nend" parses "lib LibC\nfun getch = \"get.char\"(x : Int32)\nend" - says syntax error on "return < 1" says syntax error on "return < 1" - parses "1 rescue 2" parses "1 rescue 2" - says syntax error on "break[0]" says syntax error on "break[0]" - parses "def foo(@macro); end" parses "def foo(@macro); end" - parses "\"hello \"\\\n\"world\"" parses "\"hello \"\\\n\"world\"" - parses "@@a : Foo" parses "@@a : Foo" - parses "asm(\"nop\" :: \"b\"(1), \"c\"(2) : \"eax\", \"ebx\" : \"volatile\", \"alignstack\", \"intel\")" parses "asm(\"nop\" :: \"b\"(1), \"c\"(2) : \"eax\", \"ebx\" : \"volatile\", \"alignstack\", \"intel\")" - parses "%Q{hello \\n world}" parses "%Q{hello \\n world}" - parses "foo(0, n !~ 2)" parses "foo(0, n !~ 2)" - parses "def foo; a; end" parses "def foo; a; end" - says syntax error on "return << 1" says syntax error on "return << 1" - parses "def foo(x)\n x\nend; foo = 1; b = 2; foo -b" parses "def foo(x)\n x\nend; foo = 1; b = 2; foo -b" - sets correct location of named tuple type sets correct location of named tuple type - parses "a.b *=\n1" parses "a.b *=\n1" - parses "case;end" parses "case;end" - parses "foo &.block=(0)" parses "foo &.block=(0)" - parses "x = 2; foo do bar x end" parses "x = 2; foo do bar x end" - parses "next *{1, 2}" parses "next *{1, 2}" - parses "foo(n === 2)" parses "foo(n === 2)" - parses "x = 1; foo.bar x do\nend" parses "x = 1; foo.bar x do\nend" - parses "def foo(unless foo); end" parses "def foo(unless foo); end" - parses "macro &*;end" parses "macro &*;end" - says syntax error on "+break" says syntax error on "+break" - parses "<<-FOO\n \t 1\n \t FOO" parses "<<-FOO\n \t 1\n \t FOO" - parses "def <=(*args, **opts); end" parses "def <=(*args, **opts); end" - parses "foo\n .bar" parses "foo\n .bar" - says syntax error on "macro foo" says syntax error on "macro foo" - parses "macro foo(a, @[Foo] var);end" parses "macro foo(a, @[Foo] var);end" - says syntax error on "return ... 1" says syntax error on "return ... 1" - parses "def foo(class foo); end" parses "def foo(class foo); end" - parses "a = 1; a &+= 1" parses "a = 1; a &+= 1" - says syntax error on "{\"foo\" => 1, \"bar\": 2}" says syntax error on "{\"foo\" => 1, \"bar\": 2}" - parses "def foo(a, &block); end" parses "def foo(a, &block); end" - says syntax error on "yield return" says syntax error on "yield return" - parses "\n\n__LINE__" parses "\n\n__LINE__" - parses "foo (1 + 2), 3" parses "foo (1 + 2), 3" - parses "{/ /, / /}" parses "{/ /, / /}" - says syntax error on "return do\nend" says syntax error on "return do\nend" - parses "1.as?(Bar)" parses "1.as?(Bar)" - parses "a = 1; a -= 1" parses "a = 1; a -= 1" - parses "{% begin %}%{ %s }{% end %}" parses "{% begin %}%{ %s }{% end %}" - parses "enum Foo; @@foo = 1\n A \n end" parses "enum Foo; @@foo = 1\n A \n end" - says syntax error on "1 foo" says syntax error on "1 foo" - says syntax error on "def foo(foo if); end" says syntax error on "def foo(foo if); end" - parses "foo x do\nend" parses "foo x do\nend" - parses "{% begin %}%< %s >{% end %}" parses "{% begin %}%< %s >{% end %}" - parses "foo(a: n - 2)" parses "foo(a: n - 2)" - parses "def foo(a, &block : -> Double); end" parses "def foo(a, &block : -> Double); end" - parses "1 !~ 2" parses "1 !~ 2" - says syntax error on "macro foo(**x, y)" says syntax error on "macro foo(**x, y)" - parses "f.x *= 2" parses "f.x *= 2" - parses ":\"\\u{61}\"" parses ":\"\\u{61}\"" - says syntax error on "break == 1" says syntax error on "break == 1" - parses "foo.< 1, 2" parses "foo.< 1, 2" - parses "1 !~ 2" parses "1 !~ 2" - parses "def foo(@[Foo] @var); end" parses "def foo(@[Foo] @var); end" - parses "def %(); end;" parses "def %(); end;" - parses "def foo(a, &block : Int, self -> Double); end" parses "def foo(a, &block : Int, self -> Double); end" - parses "-1.0_f32" parses "-1.0_f32" - parses "<<-HERE\n \#{1} \#{2}\n HERE" parses "<<-HERE\n \#{1} \#{2}\n HERE" - says syntax error on "x[1:-2]" says syntax error on "x[1:-2]" - parses "property protected : Int32" parses "property protected : Int32" - parses "foo(0, n &** 2)" parses "foo(0, n &** 2)" - parses "def foo(@fun); end" parses "def foo(@fun); end" - parses "foo.+(1, 2) { 3 }" parses "foo.+(1, 2) { 3 }" - parses "[1, 2]" parses "[1, 2]" - says syntax error on "next ... 1" says syntax error on "next ... 1" - says syntax error on "break &* 1" says syntax error on "break &* 1" - parses ":\"\\a\\b\\n\\r\\t\\v\\f\\e\"" parses ":\"\\a\\b\\n\\r\\t\\v\\f\\e\"" - parses "->@foo.foo?" parses "->@foo.foo?" - parses "1 == 2" parses "1 == 2" - parses "macro foo(@[Foo] var);end" parses "macro foo(@[Foo] var);end" - parses "select\nwhen foo\n2\nelse\n3\nend" parses "select\nwhen foo\n2\nelse\n3\nend" - parses "def foo(x @@out); end" parses "def foo(x @@out); end" - says syntax error on "A = begin; 1; ensure; B = 1; end" says syntax error on "A = begin; 1; ensure; B = 1; end" - parses "1 || 2" parses "1 || 2" - sets correct location of parameter in proc literal sets correct location of parameter in proc literal - parses "def <(); end" parses "def <(); end" - says syntax error on "def foo(x: Int32); end" says syntax error on "def foo(x: Int32); end" - parses "def foo(@@select); end" parses "def foo(@@select); end" - parses "Foo{\"x\" => \"y\"}" parses "Foo{\"x\" => \"y\"}" - parses "foo(a: n ^ 2)" parses "foo(a: n ^ 2)" - says syntax error on "1 ... break" says syntax error on "1 ... break" - says syntax error on "def foo(foo while); end" says syntax error on "def foo(foo while); end" - says syntax error on "*a if true" says syntax error on "*a if true" - parses "def []?; end" parses "def []?; end" - parses "unless foo; 1; end" parses "unless foo; 1; end" - parses "a.b <<=\n1" parses "a.b <<=\n1" - parses "foo \"foo bar\": 1, \"baz\": 2" parses "foo \"foo bar\": 1, \"baz\": 2" - sets correct location of protected macro in enum sets correct location of protected macro in enum - says syntax error on "def foo(foo with); end" says syntax error on "def foo(foo with); end" - parses "case 1\nwhen 1\n2\nend\nif a\nend" parses "case 1\nwhen 1\n2\nend\nif a\nend" - parses "case a\nwhen b\n1 / 2\nelse\n1 / 2\nend" parses "case a\nwhen b\n1 / 2\nelse\n1 / 2\nend" - parses "foo(//)" parses "foo(//)" - parses "foo(bar do\nend)" parses "foo(bar do\nend)" - parses "case 1\nin Foo(Int32); 2; end" parses "case 1\nin Foo(Int32); 2; end" - parses "macro foo;var unless true;end" parses "macro foo;var unless true;end" - parses "foo(n % 2)" parses "foo(n % 2)" - parses "{\n1\n}" parses "{\n1\n}" - parses "->() : Int32 { }" parses "->() : Int32 { }" - parses "return *1, 2" parses "return *1, 2" - says syntax error on "foo(**bar, out x)" says syntax error on "foo(**bar, out x)" - parses "1 ^ 2" parses "1 ^ 2" - parses "foo &.@bar" parses "foo &.@bar" - parses "def foo(a, @[Foo] var); end" parses "def foo(a, @[Foo] var); end" - says syntax error on "A = B = 1" says syntax error on "A = B = 1" - parses "%q{hello \#{foo} world}" parses "%q{hello \#{foo} world}" - parses "1.~" parses "1.~" - parses "def Foo.foo\n1\nend" parses "def Foo.foo\n1\nend" - parses "x, y, z = <<-FOO, <<-BAR, <<-BAZ\nhello\nFOO\nworld\nBAR\n!\nBAZ" parses "x, y, z = <<-FOO, <<-BAR, <<-BAZ\nhello\nFOO\nworld\nBAR\n!\nBAZ" - parses "abstract def foo" parses "abstract def foo" - says syntax error on "Foo(T, U V)" says syntax error on "Foo(T, U V)" - parses "foo(n < 2)" parses "foo(n < 2)" - parses "foo.+ do end" parses "foo.+ do end" - parses "{% unless 1; 2; end %}" parses "{% unless 1; 2; end %}" - parses "Foo(typeof(1))" parses "Foo(typeof(1))" - parses "foo.-(1, 2) { 3 }" parses "foo.-(1, 2) { 3 }" - says syntax error on "*1, a = 2" says syntax error on "*1, a = 2" - parses "def foo(**args : **Foo)\n1\nend" parses "def foo(**args : **Foo)\n1\nend" - parses "case 1; when 1 then 2; else; 3; end" parses "case 1; when 1 then 2; else; 3; end" - parses "def foo(x @@instance_sizeof); end" parses "def foo(x @@instance_sizeof); end" - parses "def foo(x @false); end" parses "def foo(x @false); end" - parses "foo.+ 1, 2" parses "foo.+ 1, 2" - parses "def foo(fun foo); end" parses "def foo(fun foo); end" - parses "def foo(x = 1, **args)\n1\nend" parses "def foo(x = 1, **args)\n1\nend" - parses "foo(z: 0, a: n > 2)" parses "foo(z: 0, a: n > 2)" - says syntax error on "def foo(unless); end" says syntax error on "def foo(unless); end" - parses "call @foo.bar" parses "call @foo.bar" - parses "a.b() /3" parses "a.b() /3" - parses "if foo; 1; elsif bar; 2; else 3; end" parses "if foo; 1; elsif bar; 2; else 3; end" - parses "begin; 1; rescue ex : ::Foo | ::Bar; 2; end" parses "begin; 1; rescue ex : ::Foo | ::Bar; 2; end" - parses "foo./" parses "foo./" - parses "offsetof(X, @a)" parses "offsetof(X, @a)" - parses "foo { a = 1 }; a" parses "foo { a = 1 }; a" - parses "->::foo" parses "->::foo" - parses "foo.== 1, 2" parses "foo.== 1, 2" - says syntax error on "case 1\nin Int32; 2; when 2" says syntax error on "case 1\nin Int32; 2; when 2" - parses "foo &./(1)" parses "foo &./(1)" - parses "foo { 1 }" parses "foo { 1 }" - parses ":^" parses ":^" - says syntax error on "foo { |(module)| }" says syntax error on "foo { |(module)| }" - says syntax error on "[\n]" says syntax error on "[\n]" - says syntax error on "macro Foo.bar;end" says syntax error on "macro Foo.bar;end" - parses "def self.|(); end;" parses "def self.|(); end;" - parses "foo = 1; ->foo.**(Int32)" parses "foo = 1; ->foo.**(Int32)" - parses "Foo(X, offsetof(Foo, @a))" parses "Foo(X, offsetof(Foo, @a))" - says syntax error on "{{ {% begin %} }}" says syntax error on "{{ {% begin %} }}" - parses "def <=(other, file = 1); end" parses "def <=(other, file = 1); end" - parses "def foo\n1\nend\nif 1\nend" parses "def foo\n1\nend\nif 1\nend" - parses "def &; end;" parses "def &; end;" - parses "{[] of Foo, self.foo}" parses "{[] of Foo, self.foo}" - says syntax error on "return 1 foo" says syntax error on "return 1 foo" - parses "def foo(x); end; x" parses "def foo(x); end; x" - says syntax error on "def foo(self); end" says syntax error on "def foo(self); end" - says syntax error on "a.b() += 1" says syntax error on "a.b() += 1" - parses "foo(z: 0, a: n - 2)" parses "foo(z: 0, a: n - 2)" - parses "property end : Int32" parses "property end : Int32" - parses "foo = 1; ->foo.&-(Int32)" parses "foo = 1; ->foo.&-(Int32)" - parses "{[] of Foo, ::foo}" parses "{[] of Foo, ::foo}" - parses "foo = 1; ->foo.=~(Int32)" parses "foo = 1; ->foo.=~(Int32)" - parses "def foo(**args)\n1\nend" parses "def foo(**args)\n1\nend" - parses "lib LibC; type A = B*; end" parses "lib LibC; type A = B*; end" - parses "macro ===;end" parses "macro ===;end" - parses "foo { |a, b, | 1 }" parses "foo { |a, b, | 1 }" - parses "lib LibC; union Foo; end end" parses "lib LibC; union Foo; end end" - parses "case 1\nwhen .!()\n2\nend" parses "case 1\nwhen .!()\n2\nend" - parses "foo" parses "foo" - parses "def foo(var : Int32 = 1); end" parses "def foo(var : Int32 = 1); end" - says syntax error on "def foo(foo require); end" says syntax error on "def foo(foo require); end" - parses "def foo(x @@case); end" parses "def foo(x @@case); end" - parses "1 + /foo/" parses "1 + /foo/" - parses "{% unless 1; 2; else 3; end %}" parses "{% unless 1; 2; else 3; end %}" - parses "def self.>=(); end;" parses "def self.>=(); end;" - parses "asm(\"nop\" ::: :)" parses "asm(\"nop\" ::: :)" - says syntax error on "->::@foo.foo" says syntax error on "->::@foo.foo" - parses "macro ~;end" parses "macro ~;end" - parses "def foo(case foo); end" parses "def foo(case foo); end" - parses "def foo(x, *, y, &); 1; end" parses "def foo(x, *, y, &); 1; end" - parses "def foo(@@extend); end" parses "def foo(@@extend); end" - parses "def foo(n); foo(n -1); end" parses "def foo(n); foo(n -1); end" - parses "a.b //=\n1" parses "a.b //=\n1" - parses "def -(); end" parses "def -(); end" - parses "[] of Int" parses "[] of Int" - parses "a.b / 2" parses "a.b / 2" - parses "1.tap do |x|; 1; rescue; x; end" parses "1.tap do |x|; 1; rescue; x; end" - parses "foo %x()" parses "foo %x()" - parses "a() /3" parses "a() /3" - says syntax error on "foo { |(end)| }" says syntax error on "foo { |(end)| }" - parses "1 &** 2" parses "1 &** 2" - says syntax error on "next &** 1" says syntax error on "next &** 1" - parses "def -(); end;" parses "def -(); end;" - parses "->\n:\nInt32\n{\n}" parses "->\n:\nInt32\n{\n}" - parses "macro []=;end" parses "macro []=;end" - parses "def foo(**args : Foo)\n1\nend" parses "def foo(**args : Foo)\n1\nend" - parses "unless foo; 1; else; 2; end" parses "unless foo; 1; else; 2; end" - says syntax error on "macro foo(x y z); end" says syntax error on "macro foo(x y z); end" - parses "->Foo.*(Int32)" parses "->Foo.*(Int32)" - says syntax error on "1 as? Bar" says syntax error on "1 as? Bar" - parses "def foo ; 1 ; end" parses "def foo ; 1 ; end" - parses "foo &.[0] = 1" parses "foo &.[0] = 1" - parses "foo = 1; ->foo.foo?" parses "foo = 1; ->foo.foo?" - parses "foo(/a/)" parses "foo(/a/)" - parses "def %; end;" parses "def %; end;" - parses "pointerof : Int32" parses "pointerof : Int32" - parses "case {1, 2}\nwhen {3, 4}\n5\nend" parses "case {1, 2}\nwhen {3, 4}\n5\nend" - parses "1 +2_i64" parses "1 +2_i64" - parses "puts {{\n1\n}}" parses "puts {{\n1\n}}" - parses "case {1, 2}\nwhen foo\n5\nend" parses "case {1, 2}\nwhen foo\n5\nend" - parses "def foo(x @true); end" parses "def foo(x @true); end" - says syntax error on "foo { |(pointerof)| }" says syntax error on "foo { |(pointerof)| }" - parses "foo(a: n & 2)" parses "foo(a: n & 2)" - parses "if foo\n1\nelse\n2\nend" parses "if foo\n1\nelse\n2\nend" - parses "def /; end;" parses "def /; end;" - parses "foo a: b(1) do\nend" parses "foo a: b(1) do\nend" - parses "a : Foo*" parses "a : Foo*" - says syntax error on "break === 1" says syntax error on "break === 1" - parses "b.c ||= 1" parses "b.c ||= 1" - says syntax error on "break * 1" says syntax error on "break * 1" - parses "Foo(T, U, 1)" parses "Foo(T, U, 1)" - parses "foo(z: 0, a: n &- 2)" parses "foo(z: 0, a: n &- 2)" - says syntax error on "def foo(foo fun); end" says syntax error on "def foo(foo fun); end" - parses "foo(a: n + 2)" parses "foo(a: n + 2)" - parses "asm(\"nop\" : \"a\"(0) : \"b\"(1))" parses "asm(\"nop\" : \"a\"(0) : \"b\"(1))" - parses "foo &.block = 0" parses "foo &.block = 0" - parses "foo = 1; ->foo.+(Int32)" parses "foo = 1; ->foo.+(Int32)" - parses "foo &.as(T)" parses "foo &.as(T)" - says syntax error on "foo &.||" says syntax error on "foo &.||" - parses "def foo(x @abstract); end" parses "def foo(x @abstract); end" - parses "a.b |=\n1" parses "a.b |=\n1" - parses "{{ nil?(foo) }}" parses "{{ nil?(foo) }}" - says syntax error on "def foo(pointerof); end" says syntax error on "def foo(pointerof); end" - says syntax error on " (1, 2, 3 end" says syntax error on " (1, 2, 3 end" - parses "case 1\nwhen .responds_to?(:foo)\n2\nend" parses "case 1\nwhen .responds_to?(:foo)\n2\nend" - parses "enum Foo; def foo; 1; end; end" parses "enum Foo; def foo; 1; end; end" - parses "<<-'HERE COMES HEREDOC'\n hello \\n world\n \#{1}\n HERE COMES HEREDOC" parses "<<-'HERE COMES HEREDOC'\n hello \\n world\n \#{1}\n HERE COMES HEREDOC" - parses "def foo(@@until); end" parses "def foo(@@until); end" - says syntax error on "break & 1" says syntax error on "break & 1" - says syntax error on "def f end" says syntax error on "def f end" - says syntax error on "return // 1" says syntax error on "return // 1" - parses "typeof(a = 1); a" parses "typeof(a = 1); a" - parses "1 \\\r\n + 2" parses "1 \\\r\n + 2" - parses "foo if 3" parses "foo if 3" - parses "def foo(select foo); end" parses "def foo(select foo); end" - parses "Foo::Bar?" parses "Foo::Bar?" - parses "1.x; foo do\nend" parses "1.x; foo do\nend" - says syntax error on "Foo({x: X, x: Y})" says syntax error on "Foo({x: X, x: Y})" - parses "def =~(); end;" parses "def =~(); end;" - parses "lib LibC\nfun getchar(a : Int, b : Float)\nend" parses "lib LibC\nfun getchar(a : Int, b : Float)\nend" - says syntax error on "{1 => 2 3 => 4}" says syntax error on "{1 => 2 3 => 4}" - parses "def foo(@offsetof); end" parses "def foo(@offsetof); end" - parses "1 & 2" parses "1 & 2" - parses "`foo\#{1}bar`" parses "`foo\#{1}bar`" - says syntax error on "->(x, y z) { }" says syntax error on "->(x, y z) { }" - parses "foo(&.as?(T).bar)" parses "foo(&.as?(T).bar)" - parses "1.=~(2)" parses "1.=~(2)" - parses "1 <= 2" parses "1 <= 2" - parses "macro foo;%var;end" parses "macro foo;%var;end" - parses "x.foo a: 1, b: 2 " parses "x.foo a: 1, b: 2 " - parses "property enum : Int32" parses "property enum : Int32" - says syntax error on "def foo(foo until); end" says syntax error on "def foo(foo until); end" - parses "Int[8, 4]" parses "Int[8, 4]" - parses "macro foo\n'\\''\nend" parses "macro foo\n'\\''\nend" - says syntax error on "a = 1; b = 2; a, b += 1, 2" says syntax error on "a = 1; b = 2; a, b += 1, 2" - parses "foo.%" parses "foo.%" - parses "def *(); end" parses "def *(); end" - says syntax error on "foo { |self| }" says syntax error on "foo { |self| }" - parses "foo z: out x; x" parses "foo z: out x; x" - parses "def foo(while foo); end" parses "def foo(while foo); end" - parses "foo(z: 0, a: n == 2)" parses "foo(z: 0, a: n == 2)" - parses "lib LibC; enum Foo; A = 1; B; end end" parses "lib LibC; enum Foo; A = 1; B; end end" - parses "next 1 if true" parses "next 1 if true" - parses "foo 1, **bar" parses "foo 1, **bar" - parses "1 ** 2" parses "1 ** 2" - parses "foo.=== do end" parses "foo.=== do end" - parses "foo = 1; ->foo.!~(Int32)" parses "foo = 1; ->foo.!~(Int32)" - parses "def foo(@@instance_sizeof); end" parses "def foo(@@instance_sizeof); end" - says syntax error on "foo { |(offsetof)| }" says syntax error on "foo { |(offsetof)| }" - parses "->Foo::Bar::Baz.foo" parses "->Foo::Bar::Baz.foo" - says syntax error on "def foo(foo out); end" says syntax error on "def foo(foo out); end" - says syntax error on "foo { |false| }" says syntax error on "foo { |false| }" - parses "def self.+; end;" parses "def self.+; end;" - parses "a = 1" parses "a = 1" - parses "foo.bar [1]" parses "foo.bar [1]" - parses "case 1\nin nil; 2; end" parses "case 1\nin nil; 2; end" - parses "asm(\"nop\" : \"a\"(0), \"b\"(1) : \"c\"(2), \"d\"(3))" parses "asm(\"nop\" : \"a\"(0), \"b\"(1) : \"c\"(2), \"d\"(3))" - parses "def foo(x = 1, *y); 1; end" parses "def foo(x = 1, *y); 1; end" - parses "n &** 2" parses "n &** 2" - says syntax error on "while break; end" says syntax error on "while break; end" - parses "foo [1]" parses "foo [1]" - parses "def =~(); end" parses "def =~(); end" - parses "property sizeof : Int32" parses "property sizeof : Int32" - parses "[\n1,2\n]" parses "[\n1,2\n]" - parses "def /(); end;" parses "def /(); end;" - parses "x[..2]" parses "x[..2]" - parses "private : Int32" parses "private : Int32" - parses "a.b /2/" parses "a.b /2/" - parses "->Foo.<=(Int32)" parses "->Foo.<=(Int32)" - parses "case 1\nelse\n2\nend" parses "case 1\nelse\n2\nend" - parses "def foo(x @with); end" parses "def foo(x @with); end" - parses "->Foo.==(Int32)" parses "->Foo.==(Int32)" - parses "Foo??" parses "Foo??" - parses "Foo(T)?" parses "Foo(T)?" - parses "def >=(*args, **opts, &); end" parses "def >=(*args, **opts, &); end" - parses "1.as(Bar)" parses "1.as(Bar)" - parses "def &(); end" parses "def &(); end" - says syntax error on "foo { |(if)| }" says syntax error on "foo { |(if)| }" - parses "foo = 1; ->foo.&**(Int32)" parses "foo = 1; ->foo.&**(Int32)" - parses "def ===(other, file = 1); end" parses "def ===(other, file = 1); end" - parses "foo(n & 2)" parses "foo(n & 2)" - parses "foo out @x; @x" parses "foo out @x; @x" - says syntax error on "->() :Int32 { }" says syntax error on "->() :Int32 { }" - says syntax error on "def foo &block : Int -> Double ; end" says syntax error on "def foo &block : Int -> Double ; end" - parses "property macro : Int32" parses "property macro : Int32" - parses "a.foo, a.bar = 1, 2" parses "a.foo, a.bar = 1, 2" - parses "a : Foo = 1" parses "a : Foo = 1" - parses "def foo; a = 1; a; end" parses "def foo; a = 1; a; end" - parses "n >> 2" parses "n >> 2" - parses "def self.~; end;" parses "def self.~; end;" - parses "def foo(@in); end" parses "def foo(@in); end" - parses "lib LibC; type A = B**; end" parses "lib LibC; type A = B**; end" - says syntax error on "if next; end" says syntax error on "if next; end" - parses "def |; end;" parses "def |; end;" - parses "next 1" parses "next 1" - parses "foo &block" parses "foo &block" - sets correct location of global path in annotation sets correct location of global path in annotation - says syntax error on "def foo(while); end" says syntax error on "def foo(while); end" - parses ":\"\\\"foo\"" parses ":\"\\\"foo\"" - parses ":\"\\\"foo\\\"\"" parses ":\"\\\"foo\\\"\"" - parses "[/ /, / /]" parses "[/ /, / /]" - parses "-@@foo" parses "-@@foo" - parses "foo.bar(1).baz" parses "foo.bar(1).baz" - parses "foo.bar= *baz" parses "foo.bar= *baz" - says syntax error on "def foo(var = x : Int); end" says syntax error on "def foo(var = x : Int); end" - parses "def foo(x @@require); end" parses "def foo(x @@require); end" - says syntax error on "<<-HERE\n One\n \#{1}\n Zero\n HERE" says syntax error on "<<-HERE\n One\n \#{1}\n Zero\n HERE" - parses "class Foo; end\nwhile true; end" parses "class Foo; end\nwhile true; end" - parses "@[Foo(1, foo: 2\n)]" parses "@[Foo(1, foo: 2\n)]" - parses "foo /;/" parses "foo /;/" - parses "def ^; end;" parses "def ^; end;" - parses "enum Foo; macro foo;end; end" parses "enum Foo; macro foo;end; end" - parses "+1" parses "+1" - says syntax error on "def foo(\"\" y); y; end" says syntax error on "def foo(\"\" y); y; end" - parses "{% x unless 1 %}" parses "{% x unless 1 %}" - parses "def foo; yield; end" parses "def foo; yield; end" - parses "{% begin %}%Q[ %s ]{% end %}" parses "{% begin %}%Q[ %s ]{% end %}" - parses "foo = 1; ->foo.<(Int32)" parses "foo = 1; ->foo.<(Int32)" - parses ":[]?" parses ":[]?" - says syntax error on "return &- 1" says syntax error on "return &- 1" - parses "def foo(next foo); end" parses "def foo(next foo); end" - parses "def foo(pointerof foo); end" parses "def foo(pointerof foo); end" - parses "def foo(abstract foo); end" parses "def foo(abstract foo); end" - says syntax error on "def foo(_ y); y; end" says syntax error on "def foo(_ y); y; end" - parses "def foo(@@var = 1); 1; end" parses "def foo(@@var = 1); 1; end" - parses "a = 1; a |=\n1" parses "a = 1; a |=\n1" - says syntax error on "def foo(select); end" says syntax error on "def foo(select); end" - parses "a = 1; a <<= 1" parses "a = 1; a <<= 1" - parses "if foo; 1; else; 2; end" parses "if foo; 1; else; 2; end" - says syntax error on "foo[1] = next" says syntax error on "foo[1] = next" - parses "def foo : Int32\n1\nend" parses "def foo : Int32\n1\nend" - parses "def foo(x @extend); end" parses "def foo(x @extend); end" - parses "~ 1" parses "~ 1" - parses "1\\\r\n + 2" parses "1\\\r\n + 2" - parses "foo(a: n &** 2)" parses "foo(a: n &** 2)" - parses "def foo(protected foo); end" parses "def foo(protected foo); end" - parses "{% begin %}{% if true %}if true{% end %}\n{% if true %}end{% end %}{% end %}" parses "{% begin %}{% if true %}if true{% end %}\n{% if true %}end{% end %}{% end %}" - parses "def foo(x @@self); end" parses "def foo(x @@self); end" - parses "foo = 1; foo -1" parses "foo = 1; foo -1" - says syntax error on "foo { |(self)| }" says syntax error on "foo { |(self)| }" - parses "{} of Int32 -> Int32 => Int32" parses "{} of Int32 -> Int32 => Int32" - parses "if : Int32" parses "if : Int32" - parses "foo(z: 0, a: n >> 2)" parses "foo(z: 0, a: n >> 2)" - parses "->::foo!" parses "->::foo!" - parses "next 1, *2" parses "next 1, *2" - parses "a = b = 2" parses "a = b = 2" - parses "1 +\n2" parses "1 +\n2" - parses "Foo?" parses "Foo?" - says syntax error on "{% unless 1 %} 2 {% elsif 3 %} 3 {% end %}" says syntax error on "{% unless 1 %} 2 {% elsif 3 %} 3 {% end %}" - parses "Set(Int32) {1, 2, 3}" parses "Set(Int32) {1, 2, 3}" - parses "require \"foo\"" parses "require \"foo\"" - parses "Foo(_)" parses "Foo(_)" - parses "offsetof(\n Foo,\n @foo\n)" parses "offsetof(\n Foo,\n @foo\n)" - parses "foo./(1, 2) { 3 }" parses "foo./(1, 2) { 3 }" - parses "foo(x, *bar, *baz, y)" parses "foo(x, *bar, *baz, y)" - parses "1_u128" parses "1_u128" - parses "break *{1, 2}" parses "break *{1, 2}" - says syntax error on "{\n1 => 2, 3 => 4\n5 => 6}" says syntax error on "{\n1 => 2, 3 => 4\n5 => 6}" - parses "begin; 1; rescue ex; 2; end" parses "begin; 1; rescue ex; 2; end" - parses "{% begin %}%r<\\A>{% end %}" parses "{% begin %}%r<\\A>{% end %}" - parses "case 1\nin Int32.class; 2; end" parses "case 1\nin Int32.class; 2; end" - parses "f.x |= 2" parses "f.x |= 2" - parses "def *(); end;" parses "def *(); end;" - parses "1\n-2" parses "1\n-2" - parses "a = 1; a[2] ||= 3" parses "a = 1; a[2] ||= 3" - parses "def >>(); end" parses "def >>(); end" - parses "alias Foo::Bar = Baz" parses "alias Foo::Bar = Baz" - parses "def foo(@typeof); end" parses "def foo(@typeof); end" - parses "\"\"" parses "\"\"" - says syntax error on "offsetof(X, 'c')" says syntax error on "offsetof(X, 'c')" - parses "foo(a: n !~ 2)" parses "foo(a: n !~ 2)" - parses "{% x if 1 %}" parses "{% x if 1 %}" - says syntax error on "break // 1" says syntax error on "break // 1" - parses "{% begin %}%w[ %s ]{% end %}" parses "{% begin %}%w[ %s ]{% end %}" - parses "->Foo.>>(Int32)" parses "->Foo.>>(Int32)" - says syntax error on "1 ? : 2 : 3" says syntax error on "1 ? : 2 : 3" - parses "module Foo\ndef foo; end; end" parses "module Foo\ndef foo; end; end" - parses "foo % Q()" parses "foo % Q()" - parses "def foo(@@enum); end" parses "def foo(@@enum); end" - says syntax error on "foo(&block) {}" says syntax error on "foo(&block) {}" - says syntax error on "def foo(extend); end" says syntax error on "def foo(extend); end" - parses "foo.<=(1, 2) { 3 }" parses "foo.<=(1, 2) { 3 }" - parses "property lib : Int32" parses "property lib : Int32" - says syntax error on "<<-FOO\n1\nFOO + 2" says syntax error on "<<-FOO\n1\nFOO + 2" - parses "macro foo;end" parses "macro foo;end" - parses "1 &* 2" parses "1 &* 2" - says syntax error on "break &+ 1" says syntax error on "break &+ 1" - says syntax error on "return > 1" says syntax error on "return > 1" - parses "lib LibC; {{ 1 }}; end" parses "lib LibC; {{ 1 }}; end" - parses "def foo(x) : Int32\n1\nend" parses "def foo(x) : Int32\n1\nend" - parses "[] of ->;" parses "[] of ->;" - parses "foo.** 1, 2" parses "foo.** 1, 2" - parses "{% if true %}\n{% end %}\n{% if true %}\n{% end %}" parses "{% if true %}\n{% end %}\n{% if true %}\n{% end %}" - parses "1 &+ 2" parses "1 &+ 2" - parses "<<-HERE\nHERE" parses "<<-HERE\nHERE" - parses "a = 1; a -=\n1" parses "a = 1; a -=\n1" - parses "Foo({\"foo\": X, \"bar\": Y})" parses "Foo({\"foo\": X, \"bar\": Y})" - parses "foo[1] /2" parses "foo[1] /2" - parses "def foo(@true); end" parses "def foo(@true); end" - parses "case 1\nin true; 2; end" parses "case 1\nin true; 2; end" - says syntax error on "break[0]= 1" says syntax error on "break[0]= 1" - parses "foo.| 1, 2" parses "foo.| 1, 2" - parses "{foo:a, bar:b}" parses "{foo:a, bar:b}" - parses "->Foo.!~(Int32)" parses "->Foo.!~(Int32)" - parses "T::U/1" parses "T::U/1" - parses "()" parses "()" - parses "foo(z: 0, a: n >= 2)" parses "foo(z: 0, a: n >= 2)" - says syntax error on "macro foo x y; end" says syntax error on "macro foo x y; end" - says syntax error on "asm(\"\" ::: \"\"(var))" says syntax error on "asm(\"\" ::: \"\"(var))" - says syntax error on "next &+ 1" says syntax error on "next &+ 1" - parses "foo.=~" parses "foo.=~" - says syntax error on "if return; end" says syntax error on "if return; end" - parses "foo()" parses "foo()" - parses "foo &->bar" parses "foo &->bar" - parses "def foo; / /; end" parses "def foo; / /; end" - parses "pointerof(@a)" parses "pointerof(@a)" - parses "foo = 1; ->foo.-(Int32)" parses "foo = 1; ->foo.-(Int32)" - says syntax error on "return | 1" says syntax error on "return | 1" - parses "x : Foo(A, *B, C)" parses "x : Foo(A, *B, C)" - parses "call foo : A, end : B" parses "call foo : A, end : B" - says syntax error on "{\n1 => 2\n3 => 4\n}" says syntax error on "{\n1 => 2\n3 => 4\n}" - says syntax error on "a, b.<=" says syntax error on "a, b.<=" - says syntax error on "case 1\nwhen Int32; 2; in 2" says syntax error on "case 1\nwhen Int32; 2; in 2" - parses "a = 1; a >>=\n1" parses "a = 1; a >>=\n1" - parses "foo.===(1, 2) { 3 }" parses "foo.===(1, 2) { 3 }" - parses "foo(&.block)" parses "foo(&.block)" - parses "foo(Foo: 1, Bar: 2)" parses "foo(Foo: 1, Bar: 2)" - parses "\"hello \"\\\r\n\"world\"" parses "\"hello \"\\\r\n\"world\"" - parses "def foo(var : self.class); end" parses "def foo(var : self.class); end" - parses "asm(\"nop\" :: \"b\"(1), \"c\"(2) : \"eax\", \"ebx\"\n: \"volatile\", \"alignstack\"\n,\n\"intel\"\n)" parses "asm(\"nop\" :: \"b\"(1), \"c\"(2) : \"eax\", \"ebx\"\n: \"volatile\", \"alignstack\"\n,\n\"intel\"\n)" - parses "macro foo(x)\n 1 + 2; end" parses "macro foo(x)\n 1 + 2; end" - says syntax error on "def foo(foo end); end" says syntax error on "def foo(foo end); end" - parses "def self.-; end;" parses "def self.-; end;" - says syntax error on "foo { |in| }" says syntax error on "foo { |in| }" - parses "yield 1 if true" parses "yield 1 if true" - parses "<<-HERE\n \#{1}One\n \#{2}Zero\n HERE" parses "<<-HERE\n \#{1}One\n \#{2}Zero\n HERE" - parses "_, *_, _, _ = 1, 2, 3" parses "_, *_, _, _ = 1, 2, 3" - says syntax error on "foo **bar, 1" says syntax error on "foo **bar, 1" - parses "def foo(\nvar); end" parses "def foo(\nvar); end" - parses "foo.|" parses "foo.|" - parses "def foo(@@begin); end" parses "def foo(@@begin); end" - says syntax error on "1 until 3" says syntax error on "1 until 3" - parses "foo.==" parses "foo.==" - says syntax error on "foo { |(enum)| }" says syntax error on "foo { |(enum)| }" - says syntax error on "foo { |macro| }" says syntax error on "foo { |macro| }" - says syntax error on "def foo(abstract); end" says syntax error on "def foo(abstract); end" - says syntax error on "fun foo\nclass" says syntax error on "fun foo\nclass" - says syntax error on "def foo(foo false); end" says syntax error on "def foo(foo false); end" - says syntax error on "foo { |(yield)| }" says syntax error on "foo { |(yield)| }" - says syntax error on "fun foo(Int32); end" says syntax error on "fun foo(Int32); end" - parses "def self.<=; end;" parses "def self.<=; end;" - parses "def >(); end" parses "def >(); end" - parses "->Foo.foo?" parses "->Foo.foo?" - says syntax error on "foo { |module| }" says syntax error on "foo { |module| }" - parses "a = 1; yield a rescue a" parses "a = 1; yield a rescue a" - parses "def self.*; end;" parses "def self.*; end;" - parses "foo unless 3" parses "foo unless 3" - parses "!a && b" parses "!a && b" - parses "asm(\"nop\" ::::)" parses "asm(\"nop\" ::::)" - parses "1.tap do; 1; rescue; 2; end" parses "1.tap do; 1; rescue; 2; end" - parses "{% if 1\n x\nend %}" parses "{% if 1\n x\nend %}" - says syntax error on "def foo(module); end" says syntax error on "def foo(module); end" - parses "{% begin %}%( %s ){% end %}" parses "{% begin %}%( %s ){% end %}" - parses "def foo(x @@return); end" parses "def foo(x @@return); end" - parses "def foo(@break); end" parses "def foo(@break); end" - parses "def self.**; end;" parses "def self.**; end;" - parses "foo(a: 1, &block)" parses "foo(a: 1, &block)" - parses "case 1; end" parses "case 1; end" - says syntax error on "break &- 1" says syntax error on "break &- 1" - parses "lib LibC\n$errno : Int32\n$errno2 : Int32\nend" parses "lib LibC\n$errno : Int32\n$errno2 : Int32\nend" - parses "x = 1; foo x {\n}" parses "x = 1; foo x {\n}" - parses "a = 1\nfoo - a" parses "a = 1\nfoo - a" - parses "macro <=>;end" parses "macro <=>;end" - says syntax error on "def foo var\n end" says syntax error on "def foo var\n end" - says syntax error on "def foo var; end" says syntax error on "def foo var; end" - parses "foo a, / /" parses "foo a, / /" - parses "macro foo; bar class: 1; end" parses "macro foo; bar class: 1; end" - says syntax error on "x : String, a = 4" says syntax error on "x : String, a = 4" - parses "A.new(\"x\", B.new(\"y\"))" parses "A.new(\"x\", B.new(\"y\"))" - parses "n =~ 2" parses "n =~ 2" - parses "->Foo.%(Int32)" parses "->Foo.%(Int32)" - parses "foo(1 + 2)" parses "foo(1 + 2)" - parses "foo = 1; ->foo.==(Int32)" parses "foo = 1; ->foo.==(Int32)" - parses "foo Bar { 1 }" parses "foo Bar { 1 }" - says syntax error on "return ^ 1" says syntax error on "return ^ 1" - says syntax error on "return <= 1" says syntax error on "return <= 1" - says syntax error on "{1, ->{ |x| x } }" says syntax error on "{1, ->{ |x| x } }" - end locations - gets corrects end location for "1.." gets corrects end location for "1.." - gets corrects end location for "puts obj.foo" gets corrects end location for "puts obj.foo" - sets correct location of `else` of if statement sets correct location of `else` of if statement - gets corrects end location for "Foo { 1 }" gets corrects end location for "Foo { 1 }" - says syntax error on "def foo(x : 1); end" says syntax error on "def foo(x : 1); end" - gets corrects end location for "{%\nif foo\n bar\n end\n%}" gets corrects end location for "{%\nif foo\n bar\n end\n%}" - gets corrects end location for "foo : Foo[42]" gets corrects end location for "foo : Foo[42]" - gets corrects end location for "foo 1, 2" gets corrects end location for "foo 1, 2" - parses "%w{one{} two}" parses "%w{one{} two}" - sets location of lib fun name sets location of lib fun name - gets corrects end location for "sizeof(Foo)" gets corrects end location for "sizeof(Foo)" - gets corrects end location for "a = 123" gets corrects end location for "a = 123" - gets corrects end location for var gets corrects end location for var - gets corrects end location for "[1, 2,]" gets corrects end location for "[1, 2,]" - sets correct location of proc literal sets correct location of proc literal - parses "%i((one two))" parses "%i((one two))" - says syntax error on "foo(1\n,2)" says syntax error on "foo(1\n,2)" - says syntax error on "case x; when :a; 2; when :a; end" says syntax error on "case x; when :a; 2; when :a; end" - gets corrects end location for "a, b = 1, 2 if 3" gets corrects end location for "a, b = 1, 2 if 3" - gets corrects end location for ":foo" gets corrects end location for ":foo" - parses "%i(foo(bar) baz)" parses "%i(foo(bar) baz)" - gets corrects end location for "foo : Foo*" gets corrects end location for "foo : Foo*" - gets corrects end location for "foo.@foo" gets corrects end location for "foo.@foo" - parses "annotation Foo::Bar\n\nend" parses "annotation Foo::Bar\n\nend" - gets corrects end location for "foo ->self.bar" gets corrects end location for "foo ->self.bar" - says syntax error on "case x; when 1..2; 2; when 1..2; end" says syntax error on "case x; when 1..2; 2; when 1..2; end" - gets corrects end location for "f.x=(foo).bar" gets corrects end location for "f.x=(foo).bar" - says syntax error on "%i(" says syntax error on "%i(" - gets corrects end location for "pointerof(@foo)" gets corrects end location for "pointerof(@foo)" - sets correct locations of keywords of exception handler sets correct locations of keywords of exception handler - parses "%w{\\{one}" parses "%w{\\{one}" - gets corrects end location for "%w(one two)" gets corrects end location for "%w(one two)" - says syntax error on "def foo(x : Int32 | (Int32, Int32)); end" says syntax error on "def foo(x : Int32 | (Int32, Int32)); end" - gets corrects end location for "macro foo;end" gets corrects end location for "macro foo;end" - gets corrects end location for block with { ... } gets corrects end location for block with { ... } - gets corrects end location for "\"hello\"" gets corrects end location for "\"hello\"" - gets corrects end location for "Foo?" gets corrects end location for "Foo?" - gets correct location of empty exception handler inside def gets correct location of empty exception handler inside def - sets correct location of vars in C struct sets correct location of vars in C struct - sets correct location of trailing rescue sets correct location of trailing rescue - gets corrects end location for "foo *bar" gets corrects end location for "foo *bar" - gets corrects end location for "::foo" gets corrects end location for "::foo" - gets corrects end location for "foo ->bar(Baz)" gets corrects end location for "foo ->bar(Baz)" - says syntax error on "%i{one}}" says syntax error on "%i{one}}" - sets correct locations of macro if / else / elsif sets correct locations of macro if / else / elsif - gets corrects end location for "foo.!()" gets corrects end location for "foo.!()" - parses "%i(one\\ two)" parses "%i(one\\ two)" - says syntax error on "%Q(" says syntax error on "%Q(" - gets corrects end location for "/foo/" gets corrects end location for "/foo/" - gets corrects end location for "foo ->@bar.baz" gets corrects end location for "foo ->@bar.baz" - sets correct location for fun def with return type sets correct location for fun def with return type - sets correct location of call name sets correct location of call name - gets corrects end location for "123" gets corrects end location for "123" - gets corrects end location for "f.x = foo" gets corrects end location for "f.x = foo" - says syntax error on "case x; when {1, 2}; 2; when {1, 2}; end" says syntax error on "case x; when {1, 2}; 2; when {1, 2}; end" - gets corrects end location for "def foo; 1; end" gets corrects end location for "def foo; 1; end" - gets corrects end location for "abstract def foo : Int32" gets corrects end location for "abstract def foo : Int32" - sets correct location of var in type declaration sets correct location of var in type declaration - gets corrects end location for "foo ->@@bar.baz=" gets corrects end location for "foo ->@@bar.baz=" - parses "%w{one\\ two}" parses "%w{one\\ two}" - gets corrects end location for "return 1" gets corrects end location for "return 1" - gets corrects end location for "1..3" gets corrects end location for "1..3" - gets corrects end location for "foo ->bar" gets corrects end location for "foo ->bar" - gets corrects end location for "a || b" gets corrects end location for "a || b" - sets correct locations of macro if / else sets correct locations of macro if / else - sets correct location for fun def sets correct location for fun def - says syntax error on "def foo(x : Array({sizeof(Int32), 2})); end" says syntax error on "def foo(x : Array({sizeof(Int32), 2})); end" - gets corrects end location for "foo ->Bar.baz=" gets corrects end location for "foo ->Bar.baz=" - says syntax error on "case x; when 1; when _; end" says syntax error on "case x; when 1; when _; end" - gets corrects end location for "unless 1; 2; end" gets corrects end location for "unless 1; 2; end" - sets correct location of `else` of unless statement sets correct location of `else` of unless statement - says syntax error on "{1\n,2}" says syntax error on "{1\n,2}" - sets correct location and end location of parenthesized empty block sets correct location and end location of parenthesized empty block - gets corrects end location for "include Foo" gets corrects end location for "include Foo" - says syntax error on "case x; when true; 2; when true; end" says syntax error on "case x; when true; 2; when true; end" - sets correct location of var in macro for loop sets correct location of var in macro for loop - gets corrects end location for "foo" gets corrects end location for "foo" - says syntax error on "def foo(x : *Int32); end" says syntax error on "def foo(x : *Int32); end" - gets corrects end location for "1 if 2" gets corrects end location for "1 if 2" - gets corrects end location for "Int[8]?" gets corrects end location for "Int[8]?" - says syntax error on "def foo(x : {Int32, (Int32, Int32)}); end" says syntax error on "def foo(x : {Int32, (Int32, Int32)}); end" - says syntax error on "%q(" says syntax error on "%q(" - gets corrects of ~ gets corrects of ~ - gets correct location after macro with yield gets correct location after macro with yield - says syntax error on "%w(" says syntax error on "%w(" - parses "annotation Foo\nend\nrequire \"bar\"" parses "annotation Foo\nend\nrequire \"bar\"" - gets corrects end location for "foo ->@bar.baz=" gets corrects end location for "foo ->@bar.baz=" - gets corrects end location for "if 1; else; 2; end" gets corrects end location for "if 1; else; 2; end" - parses "%i{(one two)}" parses "%i{(one two)}" - gets corrects end location for "@@foo" gets corrects end location for "@@foo" - gets corrects end location for "@a = uninitialized Foo" gets corrects end location for "@a = uninitialized Foo" - says syntax error on "case x; when 1; 2; when 1; end" says syntax error on "case x; when 1; 2; when 1; end" - gets corrects end location for "false" gets corrects end location for "false" - gets corrects end location for "require \"foo\"" gets corrects end location for "require \"foo\"" - gets corrects end location for "def foo; end" gets corrects end location for "def foo; end" - says syntax error on "{\"a\" : 1}" says syntax error on "{\"a\" : 1}" - sets correct location of `elsif` of if statement sets correct location of `elsif` of if statement - gets corrects end location for "foo(\n &.block\n)" gets corrects end location for "foo(\n &.block\n)" - sets location of obj.x += as call sets location of obj.x += as call - sets location of enum method sets location of enum method - gets corrects end location for "foo : Foo.class" gets corrects end location for "foo : Foo.class" - gets correct location after macro with yield gets correct location after macro with yield - gets corrects end location for "while 1; end" gets corrects end location for "while 1; end" - gets corrects end location for block with do ... end gets corrects end location for block with do ... end - doesn't override yield with macro yield doesn't override yield with macro yield - says syntax error on "case x; when _; end" says syntax error on "case x; when _; end" - gets corrects end location for "foo.bar(x) do; end" gets corrects end location for "foo.bar(x) do; end" - gets corrects end location for "module Foo; end" gets corrects end location for "module Foo; end" - says syntax error on "def foo(x : (*Int32)); end" says syntax error on "def foo(x : (*Int32)); end" - gets corrects end location for "@foo" gets corrects end location for "@foo" - says syntax error on "case x; when nil; 2; when nil; end" says syntax error on "case x; when nil; 2; when nil; end" - says syntax error on "def foo(x : {sizeof(Int32), 2}); end" says syntax error on "def foo(x : {sizeof(Int32), 2}); end" - says syntax error on "class Foo(X\n,Y); 1; end" says syntax error on "class Foo(X\n,Y); 1; end" - gets corrects end location for "foo ->self.bar=" gets corrects end location for "foo ->self.bar=" - gets corrects end location for "abstract def foo(x)" gets corrects end location for "abstract def foo(x)" - says syntax error on "{1, 2\n,3}" says syntax error on "{1, 2\n,3}" - sets correct location of element in array literal sets correct location of element in array literal - says syntax error on "def foo(x\n,y); 1; end" says syntax error on "def foo(x\n,y); 1; end" - gets corrects end location for "foo ->@@bar.baz" gets corrects end location for "foo ->@@bar.baz" - gets corrects end location for "foo : Foo**" gets corrects end location for "foo : Foo**" - parses "%w{one\ntwo}" parses "%w{one\ntwo}" - gets corrects end location for "1 rescue 2" gets corrects end location for "1 rescue 2" - sets correct location of implicit tuple literal of multi-return sets correct location of implicit tuple literal of multi-return - says syntax error on "def foo(x : (Int32, Int32)); end" says syntax error on "def foo(x : (Int32, Int32)); end" - parses "%w{one\ttwo}" parses "%w{one\ttwo}" - sets correct locations of macro if / elsif sets correct locations of macro if / elsif - says syntax error on "%x(" says syntax error on "%x(" - says syntax error on "<<-HEREDOC\n" says syntax error on "<<-HEREDOC\n" - says syntax error on "Foo(X\n,Y)" says syntax error on "Foo(X\n,Y)" - gets corrects end location for "x : Foo -> Bar" gets corrects end location for "x : Foo -> Bar" - gets corrects end location for "extend Foo" gets corrects end location for "extend Foo" - sets correct location of var in proc pointer sets correct location of var in proc pointer - gets corrects end location for "abstract def foo" gets corrects end location for "abstract def foo" - sets location of += sets location of += - parses "%w{one\\}}" parses "%w{one\\}}" - gets corrects end location for "return" gets corrects end location for "return" - gets corrects end location for "{} of Int32 => String" gets corrects end location for "{} of Int32 => String" - gets correct location with - (#1558) gets correct location with - (#1558) - gets corrects end location for "123.45" gets corrects end location for "123.45" - sets correct location for fun def on multiple lines sets correct location for fun def on multiple lines - gets corrects end location for "foo ->bar=" gets corrects end location for "foo ->bar=" - says syntax error on "case x; when [1, 2]; 2; when [1, 2]; end" says syntax error on "case x; when [1, 2]; 2; when [1, 2]; end" - says syntax error on "case x; when \"a\"; 2; when \"a\"; end" says syntax error on "case x; when \"a\"; 2; when \"a\"; end" - gets corrects end location for "->{ }" gets corrects end location for "->{ }" - sets correct location of trailing ensure sets correct location of trailing ensure - gets corrects end location for "offsetof({X, Y}, 1)" gets corrects end location for "offsetof({X, Y}, 1)" - gets corrects end location for "struct Foo; end" gets corrects end location for "struct Foo; end" - gets corrects end location for "@@a = uninitialized Foo" gets corrects end location for "@@a = uninitialized Foo" - gets corrects end location for "!foo" gets corrects end location for "!foo" - gets corrects end location for "yield" gets corrects end location for "yield" - gets corrects end location for "begin; 1; 2; 3; end" gets corrects end location for "begin; 1; 2; 3; end" - gets corrects end location for "x : Foo ->" gets corrects end location for "x : Foo ->" - gets corrects end location for var + var gets corrects end location for var + var - gets corrects end location for "'a'" gets corrects end location for "'a'" - gets corrects end location for "foo **bar" gets corrects end location for "foo **bar" - says syntax error on "%w{{one}" says syntax error on "%w{{one}" - says syntax error on "case x; when 1, _; end" says syntax error on "case x; when 1, _; end" - parses "annotation Foo; end" parses "annotation Foo; end" - gets corrects end location for "a, b = 1, 2" gets corrects end location for "a, b = 1, 2" - gets corrects end location for "{1, 2}" gets corrects end location for "{1, 2}" - gets corrects end location for "if 1; elseif; 2; end" gets corrects end location for "if 1; elseif; 2; end" - gets corrects end location for "f.x=(*foo)" gets corrects end location for "f.x=(*foo)" - parses "%w{\n}" parses "%w{\n}" - gets corrects end location for "def foo; rescue ex; end" gets corrects end location for "def foo; rescue ex; end" - gets corrects end location for "typeof(1)" gets corrects end location for "typeof(1)" - says syntax error on "%r(" says syntax error on "%r(" - gets corrects end location for "[] of Int32" gets corrects end location for "[] of Int32" - gets corrects end location for "foo.[0] = 1" gets corrects end location for "foo.[0] = 1" - says syntax error on "case x; when 'a'; 2; when 'a'; end" says syntax error on "case x; when 'a'; 2; when 'a'; end" - gets corrects end location for "foo.responds_to? :foo" gets corrects end location for "foo.responds_to? :foo" - gets corrects end location for "Foo(A)" gets corrects end location for "Foo(A)" - gets corrects end location for "foo.nil?( )" gets corrects end location for "foo.nil?( )" - says syntax error on "macro foo(x\n,y); 1; end" says syntax error on "macro foo(x\n,y); 1; end" - gets corrects end location for "nil" gets corrects end location for "nil" - gets corrects end location for "begin; 1; end" gets corrects end location for "begin; 1; end" - parses "%w{one two}" parses "%w{one two}" - gets corrects end location for "foo.!" gets corrects end location for "foo.!" - gets corrects end location for "foo(1, 2)" gets corrects end location for "foo(1, 2)" - gets corrects end location for "a && b" gets corrects end location for "a && b" - gets corrects end location for "foo.bar= *baz" gets corrects end location for "foo.bar= *baz" - gets corrects end location for "x : Foo(A, *B, C)" gets corrects end location for "x : Foo(A, *B, C)" - gets corrects end location for "foo.responds_to?(:foo)" gets corrects end location for "foo.responds_to?(:foo)" - gets corrects end location for "[1, 2]" gets corrects end location for "[1, 2]" - gets corrects end location for "{a: 1}" gets corrects end location for "{a: 1}" - says syntax error on "%i{{one}" says syntax error on "%i{{one}" - says syntax error on "case x; when /x/; 2; when /x/; end" says syntax error on "case x; when /x/; 2; when /x/; end" - sets location of top-level fun name sets location of top-level fun name - gets corrects end location for "yield 1" gets corrects end location for "yield 1" - gets corrects end location for "Foo" gets corrects end location for "Foo" - says syntax error on "Foo(x: X\n,y: Y)" says syntax error on "Foo(x: X\n,y: Y)" - says syntax error on "def foo(x : Int32, Int32); end" says syntax error on "def foo(x : Int32, Int32); end" - gets corrects end location for "foo bar, out baz" gets corrects end location for "foo bar, out baz" - gets corrects end location for "foo.nil?" gets corrects end location for "foo.nil?" - gets corrects end location for "macro foo; 123; end" gets corrects end location for "macro foo; 123; end" - says syntax error on "foo(a: 1\n,b: 2)" says syntax error on "foo(a: 1\n,b: 2)" - sets correct location of call name in operator assignment sets correct location of call name in operator assignment - gets corrects end location for "alias Foo = Bar" gets corrects end location for "alias Foo = Bar" - says syntax error on "def foo(x : (Int32, Int32) | Int32); end" says syntax error on "def foo(x : (Int32, Int32) | Int32); end" - says syntax error on "<<-HEREDOC" says syntax error on "<<-HEREDOC" - says syntax error on "case x; when X; 2; when X; end" says syntax error on "case x; when X; 2; when X; end" - gets corrects end location for "1 ensure 2" gets corrects end location for "1 ensure 2" - sets correct location of receiver var in method def sets correct location of receiver var in method def - sets correct location for fun def with body sets correct location for fun def with body - parses "annotation Foo\n\nend" parses "annotation Foo\n\nend" - says syntax error on "{\"a\": 1, \"b\" : 2}" says syntax error on "{\"a\": 1, \"b\" : 2}" - says syntax error on "%w{one}}" says syntax error on "%w{one}}" - gets corrects end location for "class Foo; end" gets corrects end location for "class Foo; end" - gets corrects end location for "foo : Foo?" gets corrects end location for "foo : Foo?" - gets corrects end location for "foo ->Bar.baz" gets corrects end location for "foo ->Bar.baz" - correctly computes line number after `\{% -` (#9857) correctly computes line number after `\{% -` (#9857) - gets corrects end location for "1.as(Int32)" gets corrects end location for "1.as(Int32)" - parses "%i{foo\\nbar baz}" parses "%i{foo\\nbar baz}" - says syntax error on "[1\n,2]" says syntax error on "[1\n,2]" - says syntax error on "{1 => 2\n,3 => 4}" says syntax error on "{1 => 2\n,3 => 4}" - gets corrects end location for "offsetof(Foo, @a)" gets corrects end location for "offsetof(Foo, @a)" - sets correct location and end location of `begin` block sets correct location and end location of `begin` block - sets correct location and end location of parenthesized block sets correct location and end location of parenthesized block - parses "abstract def foo(x)" parses "abstract def foo(x)" - says syntax error on "break &** 1" says syntax error on "break &** 1" - parses "def |(); end" parses "def |(); end" - parses "->Foo.|(Int32)" parses "->Foo.|(Int32)" - parses "-1_i64" parses "-1_i64" - parses "def foo(\nvar\n); end" parses "def foo(\nvar\n); end" - parses "foo(&.as(T).bar)" parses "foo(&.as(T).bar)" - parses "property private : Int32" parses "property private : Int32" - parses "{{ foo }}" parses "{{ foo }}" - parses "def foo(@@false); end" parses "def foo(@@false); end" - parses "/ /" parses "/ /" - parses "def foo(x @@fun); end" parses "def foo(x @@fun); end" - parses "asm(\"nop\" :::: \"volatile\")" parses "asm(\"nop\" :::: \"volatile\")" - parses "enum Foo; @[Bar]; end" parses "enum Foo; @[Bar]; end" - parses "\u3042.\u3044, \u3046.\u3048.\u304A = 1, 2" parses "\u3042.\u3044, \u3046.\u3048.\u304A = 1, 2" - parses "foo.nil?" parses "foo.nil?" - parses "foo(a: n <= 2)" parses "foo(a: n <= 2)" - parses "if foo\n1\nend" parses "if foo\n1\nend" - parses "def foo=(value); end" parses "def foo=(value); end" - parses "a = 1; a >>= 1" parses "a = 1; a >>= 1" - says syntax error on "def foo(x : U) forall; end" says syntax error on "def foo(x : U) forall; end" - says syntax error on "<<-HERE\n One\nwrong\n Zero\n HERE" says syntax error on "<<-HERE\n One\nwrong\n Zero\n HERE" - parses "foo(x:\n begin\n result : Int32 = 1\n result\n end\n )" parses "foo(x:\n begin\n result : Int32 = 1\n result\n end\n )" - parses "sizeof(X)" parses "sizeof(X)" - parses "lib LibFoo\nend\nif true\nend" parses "lib LibFoo\nend\nif true\nend" - parses "def self./(); end;" parses "def self./(); end;" - parses "def !=(other, file = 1); end" parses "def !=(other, file = 1); end" - parses "foo.[]= 1, 2" parses "foo.[]= 1, 2" - parses "1/2" parses "1/2" - parses "def foo(@end); end" parses "def foo(@end); end" - parses "foo(&.responds_to?(:foo))" parses "foo(&.responds_to?(:foo))" - parses "def ==(other, file = 1); end" parses "def ==(other, file = 1); end" - parses "def !~(); end" parses "def !~(); end" - says syntax error on "def foo(*x, &x); end" says syntax error on "def foo(*x, &x); end" - parses "foo.>" parses "foo.>" - parses "Foo(\nT,\nU,\n)" parses "Foo(\nT,\nU,\n)" - parses "a = 1; a *=\n1" parses "a = 1; a *=\n1" - parses "macro foo;bar{% begin %}body{% end %}baz;end" parses "macro foo;bar{% begin %}body{% end %}baz;end" - parses "foo out x; x" parses "foo out x; x" - parses ":=~" parses ":=~" - says syntax error on "foo { |fun| }" says syntax error on "foo { |fun| }" - parses "*a = 1, 2" parses "*a = 1, 2" - says syntax error on "A = begin; 1; rescue; B = 1; end" says syntax error on "A = begin; 1; rescue; B = 1; end" - parses "1 +2" parses "1 +2" - says syntax error on "def foo\nextend\nend" says syntax error on "def foo\nextend\nend" - parses "(1 .. )" parses "(1 .. )" - parses "macro +;end" parses "macro +;end" - parses "def foo(x @@abstract); end" parses "def foo(x @@abstract); end" - parses "macro foo; 1 + 2; end" parses "macro foo; 1 + 2; end" - parses "foo + 1" parses "foo + 1" - parses "puts {{**1}}" parses "puts {{**1}}" - parses "n / 2" parses "n / 2" - parses "foo.bar = {} of Int32 => Int32" parses "foo.bar = {} of Int32 => Int32" - parses "def >=(); end;" parses "def >=(); end;" - parses "foo 1.bar do\nend" parses "foo 1.bar do\nend" - says syntax error on "foo { |(in)| }" says syntax error on "foo { |(in)| }" - says syntax error on "{\n\"foo\"\n\"bar\"\n}" says syntax error on "{\n\"foo\"\n\"bar\"\n}" - says syntax error on "a.[]() += 1" says syntax error on "a.[]() += 1" - parses "->::Foo.foo!" parses "->::Foo.foo!" - says syntax error on "a {} += 1" says syntax error on "a {} += 1" - parses "def **; end;" parses "def **; end;" - parses "def []=(*args, **opts); end" parses "def []=(*args, **opts); end" - parses "def self.^; end;" parses "def self.^; end;" - parses "foo = 1; ->foo.&(Int32)" parses "foo = 1; ->foo.&(Int32)" - parses "property pointerof : Int32" parses "property pointerof : Int32" - parses ":foo!" parses ":foo!" - says syntax error on "b? = 1" says syntax error on "b? = 1" - says syntax error on "Foo(\"\": T)" says syntax error on "Foo(\"\": T)" - says syntax error on "1 == 2, a = 4" says syntax error on "1 == 2, a = 4" - parses "4./(2)" parses "4./(2)" - parses "foo(n // 2)" parses "foo(n // 2)" - parses "case a\nwhen b\n/ /\n\nelse\n/ /\nend" parses "case a\nwhen b\n/ /\n\nelse\n/ /\nend" - parses "puts _" parses "puts _" - says syntax error on "def foo(foo begin); end" says syntax error on "def foo(foo begin); end" - says syntax error on "foo {1, 2}" says syntax error on "foo {1, 2}" - parses "foo.bar.baz" parses "foo.bar.baz" - parses "def self.!=(); end;" parses "def self.!=(); end;" - parses "Foo(\nx:\nT,\ny:\nU,\n)" parses "Foo(\nx:\nT,\ny:\nU,\n)" - says syntax error on "*a === 1" says syntax error on "*a === 1" - parses "foo(z: 0, a: n ^ 2)" parses "foo(z: 0, a: n ^ 2)" - says syntax error on "def foo(x, x); end" says syntax error on "def foo(x, x); end" - parses "macro foo;bar{% for x in y %}\\ \n body{% end %}\\ baz;end" parses "macro foo;bar{% for x in y %}\\ \n body{% end %}\\ baz;end" - parses "foo.[]=(1, 2)" parses "foo.[]=(1, 2)" - parses "puts __DIR__" parses "puts __DIR__" - says syntax error on "def =\nend" says syntax error on "def =\nend" - parses "def foo(@@include); end" parses "def foo(@@include); end" - parses "def foo(x @break); end" parses "def foo(x @break); end" - says syntax error on "macro as?; end" says syntax error on "macro as?; end" - parses "Int[8]?" parses "Int[8]?" - parses "->Foo.**(Int32)" parses "->Foo.**(Int32)" - says syntax error on "if break; end" says syntax error on "if break; end" - parses "foo = 1; ->foo.^(Int32)" parses "foo = 1; ->foo.^(Int32)" - parses "a b() {}" parses "a b() {}" - parses "{%\n1\n2\n3\n%}" parses "{%\n1\n2\n3\n%}" - parses "(1 ... )" parses "(1 ... )" - parses "/foo/" parses "/foo/" - parses "extend : Int32" parses "extend : Int32" - says syntax error on "def foo(foo def); end" says syntax error on "def foo(foo def); end" - parses "<<-HERE\n One\n \n Zero\n HERE" parses "<<-HERE\n One\n \n Zero\n HERE" - parses "foo(n | 2)" parses "foo(n | 2)" - says syntax error on "A = (B = 1)" says syntax error on "A = (B = 1)" - parses "macro >=;end" parses "macro >=;end" - parses "instance_sizeof : Int32" parses "instance_sizeof : Int32" - parses "a = 1; a /b" parses "a = 1; a /b" - parses "def foo(@unless); end" parses "def foo(@unless); end" - parses "Foo(1)" parses "Foo(1)" - parses "Foo({x: X, typeof: Y})" parses "Foo({x: X, typeof: Y})" - parses "macro foo(**args)\n1\nend" parses "macro foo(**args)\n1\nend" - parses "{foo:\"a\", bar:\"b\"}" parses "{foo:\"a\", bar:\"b\"}" - parses "macro `;end" parses "macro `;end" - parses "/ hi /" parses "/ hi /" - parses "foo(regex: //)" parses "foo(regex: //)" - parses "(bar do\nend)" parses "(bar do\nend)" - parses ":!~" parses ":!~" - parses "def foo(x @enum); end" parses "def foo(x @enum); end" - says syntax error on "macro foo x; 1 + 2; end" says syntax error on "macro foo x; 1 + 2; end" - says syntax error on "def foo(**args, x); end" says syntax error on "def foo(**args, x); end" - says syntax error on "break .. 1" says syntax error on "break .. 1" - parses "x.foo(a: 1, b: 2)" parses "x.foo(a: 1, b: 2)" - parses "foo 1, 2" parses "foo 1, 2" - parses "a, *b = 1, 2" parses "a, *b = 1, 2" - parses "def &**(); end" parses "def &**(); end" - parses "macro foo\n'\\\\'\nend" parses "macro foo\n'\\\\'\nend" - parses "a = 1; a <<=\n1" parses "a = 1; a <<=\n1" - parses ":\"\"" parses ":\"\"" - parses "foo out _" parses "foo out _" - parses "n >= 2" parses "n >= 2" - parses "{[] of Foo, Bar::Baz.new}" parses "{[] of Foo, Bar::Baz.new}" - says syntax error on "<<-HERE\n One\n \#{1}\n wrong\#{1}\n HERE" says syntax error on "<<-HERE\n One\n \#{1}\n wrong\#{1}\n HERE" - parses "foo(z: 0, a: n / 2)" parses "foo(z: 0, a: n / 2)" - says syntax error on "unless return; end" says syntax error on "unless return; end" - parses "def foo(@@nil); end" parses "def foo(@@nil); end" - parses "foo.!=(1, 2) { 3 }" parses "foo.!=(1, 2) { 3 }" - parses "foo.^(1, 2)" parses "foo.^(1, 2)" - parses "%r(\\/)" parses "%r(\\/)" - parses "a = 1; a ensure a" parses "a = 1; a ensure a" - parses "1+0" parses "1+0" - parses "foo.!~" parses "foo.!~" - parses "def foo(var : Char[N]); end" parses "def foo(var : Char[N]); end" - parses "a = 1; a /=\n1" parses "a = 1; a /=\n1" - parses "foo.**" parses "foo.**" - parses "abstract class Foo; end" parses "abstract class Foo; end" - parses "def foo(x @require); end" parses "def foo(x @require); end" - parses "'a'" parses "'a'" - parses "def foo(x @in); end" parses "def foo(x @in); end" - parses "x[0] ? 1 : 0" parses "x[0] ? 1 : 0" - parses "<<-HERE1; <<-HERE2\nhere1\nHERE1\nHERE2" parses "<<-HERE1; <<-HERE2\nhere1\nHERE1\nHERE2" - parses "foo = 1; ->foo.&+(Int32)" parses "foo = 1; ->foo.&+(Int32)" - parses "1 +2.0" parses "1 +2.0" - says syntax error on "def foo(foo macro); end" says syntax error on "def foo(foo macro); end" - says syntax error on "foo { |with| }" says syntax error on "foo { |with| }" - parses "foo.=~(1, 2) { 3 }" parses "foo.=~(1, 2) { 3 }" - says syntax error on "return.as(Int32)" says syntax error on "return.as(Int32)" - parses "lib : Int32" parses "lib : Int32" - says syntax error on "foo { |while| }" says syntax error on "foo { |while| }" - parses "property struct : Int32" parses "property struct : Int32" - parses "def foo(@@unless); end" parses "def foo(@@unless); end" - parses "x = 1 ensure 2" parses "x = 1 ensure 2" - parses "def >(); end;" parses "def >(); end;" - says syntax error on "foo { |select| }" says syntax error on "foo { |select| }" - parses "1 ... 2" parses "1 ... 2" - parses "foo %Q" parses "foo %Q" - parses "-> : Int32 { }" parses "-> : Int32 { }" - parses "f.x = - 1" parses "f.x = - 1" - parses "def self./(); end;" parses "def self./(); end;" - says syntax error on "1 unless break" says syntax error on "1 unless break" - parses "foo(a: n << 2)" parses "foo(a: n << 2)" - says syntax error on "foo { |offsetof| }" says syntax error on "foo { |offsetof| }" - says syntax error on "Foo(T U)" says syntax error on "Foo(T U)" - parses "def foo(&block); end" parses "def foo(&block); end" - parses "foo(a: n >= 2)" parses "foo(a: n >= 2)" - parses "def foo(x @offsetof); end" parses "def foo(x @offsetof); end" - parses "`foo\\``" parses "`foo\\``" - parses "foo.*" parses "foo.*" - parses "def foo(@@require); end" parses "def foo(@@require); end" - says syntax error on "def foo(in); end" says syntax error on "def foo(in); end" - parses "def foo(x @module); end" parses "def foo(x @module); end" - parses ":-" parses ":-" - says syntax error on "def foo(var = 1 : Int32); end" says syntax error on "def foo(var = 1 : Int32); end" - parses "def *; end;" parses "def *; end;" - says syntax error on "next | 1" says syntax error on "next | 1" - parses "case 1\nwhen .as?(T)\n2\nend" parses "case 1\nwhen .as?(T)\n2\nend" - parses "asm(\"nop\" :: : :)" parses "asm(\"nop\" :: : :)" - says syntax error on "break / 1" says syntax error on "break / 1" - parses "def foo(var : Int); end" parses "def foo(var : Int); end" - parses "<<-HERE\r\n One\r\n Zero\r\n HERE" parses "<<-HERE\r\n One\r\n Zero\r\n HERE" - parses "case 1\nwhen 1\n2\nend" parses "case 1\nwhen 1\n2\nend" - parses "{[] of Foo, Bar::Baz * 2}" parses "{[] of Foo, Bar::Baz * 2}" - parses "macro >>;end" parses "macro >>;end" - parses "foo *{1}" parses "foo *{1}" - parses "{% begin %}%Q{ %s }{% end %}" parses "{% begin %}%Q{ %s }{% end %}" - says syntax error on "def foo(begin); end" says syntax error on "def foo(begin); end" - says syntax error on "class Foo(T, T); end" says syntax error on "class Foo(T, T); end" - parses "1.as Bar" parses "1.as Bar" - parses "def foo(); 1; rescue; 2; end" parses "def foo(); 1; rescue; 2; end" - parses "responds_to?(:foo)" parses "responds_to?(:foo)" - says syntax error on "macro foo *y;end" says syntax error on "macro foo *y;end" - parses "foo(/ /, / /)" parses "foo(/ /, / /)" - parses "Foo(x: U)" parses "Foo(x: U)" - says syntax error on "break % 1" says syntax error on "break % 1" - says syntax error on "{foo: 1\nbar: 2}" says syntax error on "{foo: 1\nbar: 2}" - parses "def foo(x @class); end" parses "def foo(x @class); end" - parses "{% begin %}%r[\\A]{% end %}" parses "{% begin %}%r[\\A]{% end %}" - parses "select\nwhen foo\n2\nend" parses "select\nwhen foo\n2\nend" - says syntax error on "def foo(struct); end" says syntax error on "def foo(struct); end" - parses "def foo(a, & : Int -> Double); end" parses "def foo(a, & : Int -> Double); end" - parses "macro <<;end" parses "macro <<;end" - parses "macro foo;unless %var;true;end;end" parses "macro foo;unless %var;true;end;end" - parses "x = 1; ->{ x }" parses "x = 1; ->{ x }" - says syntax error on "\"\#{<<-HERE}\"\nHERE" says syntax error on "\"\#{<<-HERE}\"\nHERE" - parses "1 // 2" parses "1 // 2" - parses "1 * 2" parses "1 * 2" - says syntax error on "def foo(foo asm); end" says syntax error on "def foo(foo asm); end" - parses "1 >= 2" parses "1 >= 2" - says syntax error on "{1 => 2, 3 => 4 5 => 6}" says syntax error on "{1 => 2, 3 => 4 5 => 6}" - parses "foo { |(a, (b, (c, d)))| }" parses "foo { |(a, (b, (c, d)))| }" - parses "next;" parses "next;" - parses "def foo(x @next); end" parses "def foo(x @next); end" - parses "yield : Int32" parses "yield : Int32" - parses "<<-EOF.x\n foo\nEOF" parses "<<-EOF.x\n foo\nEOF" - says syntax error on "def foo=(*args); end" says syntax error on "def foo=(*args); end" - parses "def self.>; end;" parses "def self.>; end;" - parses "def foo(var = 1); end" parses "def foo(var = 1); end" - parses "def foo(var1, var2); end" parses "def foo(var1, var2); end" - parses "->@@foo.foo?" parses "->@@foo.foo?" - parses "foo.!=" parses "foo.!=" - says syntax error on "*a, 1 = 2" says syntax error on "*a, 1 = 2" - parses "def self.>(); end;" parses "def self.>(); end;" - parses "begin; 1; rescue ex : Foo | Bar; 2; end" parses "begin; 1; rescue ex : Foo | Bar; 2; end" - parses "foo = 1; ->foo.bar(Int32)" parses "foo = 1; ->foo.bar(Int32)" - parses "foo(\n begin\n result : Int32 = 1\n result\n end\n )" parses "foo(\n begin\n result : Int32 = 1\n result\n end\n )" - says syntax error on "next / 1" says syntax error on "next / 1" - parses "->::foo=" parses "->::foo=" - says syntax error on "{1, ->do\n|x| x\end }" says syntax error on "{1, ->do\n|x| x\end }" - parses "foo%Q" parses "foo%Q" - parses "def <<(); end" parses "def <<(); end" - says syntax error on "def foo(fun); end" says syntax error on "def foo(fun); end" - parses "class Foo; end" parses "class Foo; end" - says syntax error on "def foo(return); end" says syntax error on "def foo(return); end" - parses "a, b = 1, 2" parses "a, b = 1, 2" - says syntax error on "def foo(if); end" says syntax error on "def foo(if); end" - parses "foo.&(1, 2)" parses "foo.&(1, 2)" - parses "property ensure : Int32" parses "property ensure : Int32" - says syntax error on "def foo(true); end" says syntax error on "def foo(true); end" - parses "def foo(@abstract); end" parses "def foo(@abstract); end" - parses "def foo(x @private); end" parses "def foo(x @private); end" - says syntax error on "next &- 1" says syntax error on "next &- 1" - parses "def +(); end;" parses "def +(); end;" - parses "def >=(*args, **opts); end" parses "def >=(*args, **opts); end" - parses "def foo(def foo); end" parses "def foo(def foo); end" - parses "@[Foo::Bar]" parses "@[Foo::Bar]" - parses "case foo; end" parses "case foo; end" - parses "def foo(x = __LINE__); end" parses "def foo(x = __LINE__); end" - parses "def foo(@@end); end" parses "def foo(@@end); end" - parses "::T/1" parses "::T/1" - parses "private def foo; end" parses "private def foo; end" - parses "foo 1" parses "foo 1" - says syntax error on "<<-HERE\n One\n wrong\n Zero\n HERE" says syntax error on "<<-HERE\n One\n wrong\n Zero\n HERE" - says syntax error on "def foo(*a foo); end" says syntax error on "def foo(*a foo); end" - parses "extend self" parses "extend self" - parses "@foo = 1" parses "@foo = 1" - parses "def foo(x @fun); end" parses "def foo(x @fun); end" - parses "foo(0, n >> 2)" parses "foo(0, n >> 2)" - parses ":[]=" parses ":[]=" - parses "@[Foo()]" parses "@[Foo()]" - parses "asm : Int32" parses "asm : Int32" - parses "macro >;end" parses "macro >;end" - parses "property class : Int32" parses "property class : Int32" - parses "true" parses "true" - parses "foo.!= do end" parses "foo.!= do end" - parses ":[]?" parses ":[]?" - parses "case 1; when 1; 2; else; 3; end" parses "case 1; when 1; 2; else; 3; end" - parses "a = 1; a *= 1" parses "a = 1; a *= 1" - parses "def foo(x @sizeof); end" parses "def foo(x @sizeof); end" - parses "lib LibC\n$errno : B, C -> D\nend" parses "lib LibC\n$errno : B, C -> D\nend" - says syntax error on "next === 1" says syntax error on "next === 1" - parses "foo.+(1, 2)" parses "foo.+(1, 2)" - parses "foo(a: n * 2)" parses "foo(a: n * 2)" - parses "f.x Foo.new" parses "f.x Foo.new" - parses "macro foo(@[Foo] var);end" parses "macro foo(@[Foo] var);end" - says syntax error on "next[]" says syntax error on "next[]" - says syntax error on "case 1; when return; end; end" says syntax error on "case 1; when return; end; end" - parses "macro [];end" parses "macro [];end" - parses "enum Foo; A = 1\ndef foo; 1; end\ndef bar; 2; end\nend" parses "enum Foo; A = 1\ndef foo; 1; end\ndef bar; 2; end\nend" - parses "def foo(x @protected); end" parses "def foo(x @protected); end" - parses "f.x &= 2" parses "f.x &= 2" - parses "puts __FILE__" parses "puts __FILE__" - parses "class Foo < Bar; end" parses "class Foo < Bar; end" - says syntax error on "1 if return" says syntax error on "1 if return" - says syntax error on "def foo\nclass\nend" says syntax error on "def foo\nclass\nend" - says syntax error on "def foo\nmodule\nend" says syntax error on "def foo\nmodule\nend" - parses "macro foo(x, *y);end" parses "macro foo(x, *y);end" - parses "def ~; end;" parses "def ~; end;" - parses "until true; 1; end;" parses "until true; 1; end;" - says syntax error on "next <= 1" says syntax error on "next <= 1" - parses "foo(z: 0, a: n % 2)" parses "foo(z: 0, a: n % 2)" - says syntax error on "def foo @@var, █ end" says syntax error on "def foo @@var, █ end" - parses "macro !~;end" parses "macro !~;end" - says syntax error on "def foo(foo in); end" says syntax error on "def foo(foo in); end" - says syntax error on "A = foo { B = 1 }" says syntax error on "A = foo { B = 1 }" - says syntax error on "{a: 1, b: 2 c: 3}" says syntax error on "{a: 1, b: 2 c: 3}" - says syntax error on "1 as Bar" says syntax error on "1 as Bar" - parses "def foo(out foo); end" parses "def foo(out foo); end" - parses "&- 1" parses "&- 1" - parses "n &- 2" parses "n &- 2" - parses "a.b ^=\n1" parses "a.b ^=\n1" - says syntax error on "a = 1, 2, 3" says syntax error on "a = 1, 2, 3" - parses "def foo(end foo); end" parses "def foo(end foo); end" - says syntax error on "foo { |unless| }" says syntax error on "foo { |unless| }" - parses "1.is_a?(\n Int32\n)" parses "1.is_a?(\n Int32\n)" - parses "instance_sizeof(X)" parses "instance_sizeof(X)" - parses "->foo!" parses "->foo!" - parses "foo result : Int32; result" parses "foo result : Int32; result" - parses "1.as(\n Int32\n)" parses "1.as(\n Int32\n)" - parses "Foo(Bar())" parses "Foo(Bar())" - says syntax error on "def foo(foo next); end" says syntax error on "def foo(foo next); end" - says syntax error on "foo(return)" says syntax error on "foo(return)" - parses "n === 2" parses "n === 2" - calls with blocks within index operator (#12818) - parses "foo[bar { 1 }]" parses "foo[bar { 1 }]" - parses "foo[bar do; 1; end]" parses "foo[bar do; 1; end]" - parses "foo.[bar { 1 }]" parses "foo.[bar { 1 }]" - parses "foo.[](bar { 1 })" parses "foo.[](bar { 1 })" - parses "foo.[bar do; 1; end]" parses "foo.[bar do; 1; end]" - parses "foo.[](bar do; 1; end)" parses "foo.[](bar do; 1; end)" - parses "Foo(T, 1, U)" parses "Foo(T, 1, U)" - parses "x[a: 1, b: 2]" parses "x[a: 1, b: 2]" - parses "def foo(typeof foo); end" parses "def foo(typeof foo); end" - parses "def foo(x @def); end" parses "def foo(x @def); end" - says syntax error on "break ? 1 : 2" says syntax error on "break ? 1 : 2" - says syntax error on "def self.nil?; end" says syntax error on "def self.nil?; end" - parses "def foo(x @@until); end" parses "def foo(x @@until); end" - parses "def self.%(); end;" parses "def self.%(); end;" - parses "{} of Int => Double" parses "{} of Int => Double" - parses "@@foo = 1" parses "@@foo = 1" - parses "T/1" parses "T/1" - parses "macro foo;%var{1, x} = hello;end" parses "macro foo;%var{1, x} = hello;end" - parses "foo.-" parses "foo.-" - says syntax error on "def foo *y; 1; end" says syntax error on "def foo *y; 1; end" - parses "a = 1; yield a ensure a" parses "a = 1; yield a ensure a" - says syntax error on "*a, *b = 1" says syntax error on "*a, *b = 1" - says syntax error on "def foo(require); end" says syntax error on "def foo(require); end" - says syntax error on "foo { |(unless)| }" says syntax error on "foo { |(unless)| }" - parses "def foo(x @struct); end" parses "def foo(x @struct); end" - parses "puts %w(one two)" parses "puts %w(one two)" - parses "def ^(); end" parses "def ^(); end" - says syntax error on "foo.responds_to?" says syntax error on "foo.responds_to?" - says syntax error on "foo { |nil| }" says syntax error on "foo { |nil| }" - says syntax error on "def foo(foo instance_sizeof); end" says syntax error on "def foo(foo instance_sizeof); end" - parses "def /; end;" parses "def /; end;" - parses "foo %i" parses "foo %i" - parses "->Foo.<<(Int32)" parses "->Foo.<<(Int32)" - parses "unless : Int32" parses "unless : Int32" - says syntax error on "def foo\nfun\nend" says syntax error on "def foo\nfun\nend" - says syntax error on "def foo(sizeof); end" says syntax error on "def foo(sizeof); end" - parses "1 ensure 2 if 3" parses "1 ensure 2 if 3" - sets correct location of instance variable in proc pointer sets correct location of instance variable in proc pointer - parses "<<-'EOF'.x\n foo\nEOF" parses "<<-'EOF'.x\n foo\nEOF" - parses "{% begin %}%| %s |{% end %}" parses "{% begin %}%| %s |{% end %}" - says syntax error on "def foo(**args, *x); end" says syntax error on "def foo(**args, *x); end" - parses "false : Int32" parses "false : Int32" - parses "return" parses "return" - parses "foo %q" parses "foo %q" - parses "Int[8]" parses "Int[8]" - parses "nil?" parses "nil?" - parses "foo(a: n // 2)" parses "foo(a: n // 2)" - parses "foo(z: 0, a: n * 2)" parses "foo(z: 0, a: n * 2)" - parses "extend Foo\nif true; end" parses "extend Foo\nif true; end" - parses "def foo(@sizeof); end" parses "def foo(@sizeof); end" - parses "call \"foo\"" parses "call \"foo\"" - says syntax error on "[1 1]" says syntax error on "[1 1]" - says syntax error on "foo { |return| }" says syntax error on "foo { |return| }" - parses "lib LibC\nfun getch = GetChar\nend" parses "lib LibC\nfun getch = GetChar\nend" - parses "[] of ->\n1" parses "[] of ->\n1" - says syntax error on "->::foo.foo" says syntax error on "->::foo.foo" - says syntax error on "fun foo(x : Int32, x : Int64); end" says syntax error on "fun foo(x : Int32, x : Int64); end" - says syntax error on "return false foo" says syntax error on "return false foo" - parses "a.b >>=\n1" parses "a.b >>=\n1" - parses "foo { |a, (b, c), (d, e)| a; b; c; d; e }" parses "foo { |a, (b, c), (d, e)| a; b; c; d; e }" - says syntax error on "foo { |(break)| }" says syntax error on "foo { |(break)| }" - says syntax error on "(1, 2 3)" says syntax error on "(1, 2 3)" - parses "foo %w" parses "foo %w" - parses "foo(a: n == 2)" parses "foo(a: n == 2)" - parses "var.@foo.@bar" parses "var.@foo.@bar" - parses "foo.> 1, 2" parses "foo.> 1, 2" - parses "if (\ntrue\n)\n1\nend" parses "if (\ntrue\n)\n1\nend" - parses "::A::B" parses "::A::B" - says syntax error on "Hash{\"foo\": 1, \"bar\": 2}" says syntax error on "Hash{\"foo\": 1, \"bar\": 2}" - parses "foo.as(Bar)" parses "foo.as(Bar)" - says syntax error on "foo { |(sizeof)| }" says syntax error on "foo { |(sizeof)| }" - parses "property break : Int32" parses "property break : Int32" - says syntax error on "foo { |(extend)| }" says syntax error on "foo { |(extend)| }" - says syntax error on "while 1 == 1 a; end" says syntax error on "while 1 == 1 a; end" - parses "foo.=~ 1, 2" parses "foo.=~ 1, 2" - parses "def +(); end" parses "def +(); end" - parses "class Foo(Type); end" parses "class Foo(Type); end" - parses "fun foo : Int32; 1; end; 2" parses "fun foo : Int32; 1; end; 2" - parses "[\n1, 2]" parses "[\n1, 2]" - parses "def []=(value); end" parses "def []=(value); end" - parses "{%\nif 1; 2; end\n%}" parses "{%\nif 1; 2; end\n%}" - says syntax error on "alias Foo?" says syntax error on "alias Foo?" - says syntax error on "+return" says syntax error on "+return" - says syntax error on "def foo\nstruct\nend" says syntax error on "def foo\nstruct\nend" - parses "1 === 2" parses "1 === 2" - parses "Foo({String, ->, ->})" parses "Foo({String, ->, ->})" - parses "property asm : Int32" parses "property asm : Int32" - parses "def foo(@@true); end" parses "def foo(@@true); end" - says syntax error on "<<-HERE\n One\n \#{1}\n wrong\n HERE" says syntax error on "<<-HERE\n One\n \#{1}\n wrong\n HERE" - parses "def foo(x, *y : Int32); 1; end" parses "def foo(x, *y : Int32); 1; end" - parses "a = 1; a **= 1" parses "a = 1; a **= 1" - parses "/\\ /" parses "/\\ /" - parses "break 1, *2" parses "break 1, *2" - says syntax error on "macro foo(x : Int32); end" says syntax error on "macro foo(x : Int32); end" - parses "def foo; yield(1); end" parses "def foo; yield(1); end" - parses "def foo(x @@protected); end" parses "def foo(x @@protected); end" - parses "def foo(x @@break); end" parses "def foo(x @@break); end" - parses "property typeof : Int32" parses "property typeof : Int32" - parses "1 ensure 2" parses "1 ensure 2" - parses "case 1\nwhen .as(T)\n2\nend" parses "case 1\nwhen .as(T)\n2\nend" - says syntax error on "foo { |case| }" says syntax error on "foo { |case| }" - parses "def foo; end" parses "def foo; end" - says syntax error on "return[0]" says syntax error on "return[0]" - parses "def self.foo=\n1\nend" parses "def self.foo=\n1\nend" - parses "2**3**4" parses "2**3**4" - parses "foo %r()" parses "foo %r()" - says syntax error on "def self.responds_to?; end" says syntax error on "def self.responds_to?; end" - parses "foo(0, n & 2)" parses "foo(0, n & 2)" - says syntax error on "macro def foo : String; 1; end" says syntax error on "macro def foo : String; 1; end" - parses "macro &**;end" parses "macro &**;end" - parses "foo(n << 2)" parses "foo(n << 2)" - parses "Foo(T | U)" parses "Foo(T | U)" - parses "case / /; when / /; / /; else; / /; end" parses "case / /; when / /; / /; else; / /; end" - parses "begin 1 end / 2" parses "begin 1 end / 2" - parses "<<-HERE1; <<-HERE2\nHERE1\nHERE2" parses "<<-HERE1; <<-HERE2\nHERE1\nHERE2" - parses "foo.|(1, 2)" parses "foo.|(1, 2)" - says syntax error on "break ** 1" says syntax error on "break ** 1" - says syntax error on "foo &.||()" says syntax error on "foo &.||()" - says syntax error on "1 then" says syntax error on "1 then" - parses "foo.=~(1, 2)" parses "foo.=~(1, 2)" - says syntax error on "1 .. return" says syntax error on "1 .. return" - parses "Int[8, 4,]" parses "Int[8, 4,]" - parses "foo(n ** 2)" parses "foo(n ** 2)" - parses "a = 1; a ^= 1" parses "a = 1; a ^= 1" - parses "->Foo.//(Int32)" parses "->Foo.//(Int32)" - parses "foo\n #comment\n .bar" parses "foo\n #comment\n .bar" - says syntax error on "false foo" says syntax error on "false foo" - parses "abstract : Int32" parses "abstract : Int32" - parses "def : Int32" parses "def : Int32" - parses "1 -2_i64" parses "1 -2_i64" - parses "macro foo;bar{% if x %}body{% end %}baz;end" parses "macro foo;bar{% if x %}body{% end %}baz;end" - parses "1 ** -x" parses "1 ** -x" - parses "foo &.as?(T)" parses "foo &.as?(T)" - parses "1 <=> 2" parses "1 <=> 2" - says syntax error on "foo { |asm| }" says syntax error on "foo { |asm| }" - says syntax error on "Foo(T, x: U)" says syntax error on "Foo(T, x: U)" - parses "->::Foo.foo=" parses "->::Foo.foo=" - parses "foo.>(1, 2) { 3 }" parses "foo.>(1, 2) { 3 }" - parses "1.!" parses "1.!" - parses "->Foo.>=(Int32)" parses "->Foo.>=(Int32)" - says syntax error on "foo[return]" says syntax error on "foo[return]" - parses "{/ / => / /, / / => / /}" parses "{/ / => / /, / / => / /}" - parses ":>>" parses ":>>" - parses "foo..2" parses "foo..2" - says syntax error on "a += 1" says syntax error on "a += 1" - parses "foo\n.bar" parses "foo\n.bar" - parses "/fo\#{1}o/" parses "/fo\#{1}o/" - parses "foo = 1; ->foo.<=(Int32)" parses "foo = 1; ->foo.<=(Int32)" - parses "case 1\nwhen 1\n2\nelse\n3\nend" parses "case 1\nwhen 1\n2\nelse\n3\nend" - says syntax error on "def foo(next); end" says syntax error on "def foo(next); end" - parses "foo.!~ 1, 2" parses "foo.!~ 1, 2" - parses "n ^ 2" parses "n ^ 2" - parses "def foo(true foo); end" parses "def foo(true foo); end" - says syntax error on "enum Foo; A B; end" says syntax error on "enum Foo; A B; end" - parses "while : Int32" parses "while : Int32" - parses "r = 1; r.x += 2" parses "r = 1; r.x += 2" - says syntax error on "def self.as; end" says syntax error on "def self.as; end" - says syntax error on "def foo(foo private); end" says syntax error on "def foo(foo private); end" - says syntax error on "def foo(foo offsetof); end" says syntax error on "def foo(foo offsetof); end" - parses "n &* 2" parses "n &* 2" - parses "foo.* do end" parses "foo.* do end" - parses "def foo(x @@pointerof); end" parses "def foo(x @@pointerof); end" - parses "def foo(@with); end" parses "def foo(@with); end" - parses "foo.bar" parses "foo.bar" - parses "property include : Int32" parses "property include : Int32" - parses "{1}" parses "{1}" - parses "def foo(x : *T -> R); end" parses "def foo(x : *T -> R); end" - says syntax error on "def foo(x y, x z); end" says syntax error on "def foo(x y, x z); end" - parses "protected : Int32" parses "protected : Int32" - parses "->Foo.<(Int32)" parses "->Foo.<(Int32)" - says syntax error on "return >> 1" says syntax error on "return >> 1" - parses "def self.!=; end;" parses "def self.!=; end;" - parses "a ? 1 : b ? 2 : c ? 3 : 0" parses "a ? 1 : b ? 2 : c ? 3 : 0" - parses "foo.<= 1, 2" parses "foo.<= 1, 2" - parses "{foo:'a', bar:'b'}" parses "{foo:'a', bar:'b'}" - parses "foo.== do end" parses "foo.== do end" - parses "def foo; x { |_| 1 }; end" parses "def foo; x { |_| 1 }; end" - parses "1\\\n + 2" parses "1\\\n + 2" - parses "case {1}\nin {nil}; 2; end" parses "case {1}\nin {nil}; 2; end" - parses "->Foo.&-(Int32)" parses "->Foo.&-(Int32)" - parses "def foo(x @lib); end" parses "def foo(x @lib); end" - says syntax error on "return * 1" says syntax error on "return * 1" - parses ":&" parses ":&" - parses "1 < 2" parses "1 < 2" - parses "break {1, 2}" parses "break {1, 2}" - says syntax error on "def self.as?; end" says syntax error on "def self.as?; end" - parses "foo = 1; ->foo.&*(Int32)" parses "foo = 1; ->foo.&*(Int32)" - parses "end : Int32" parses "end : Int32" - says syntax error on "def foo=(&block); end" says syntax error on "def foo=(&block); end" - parses "def |(); end;" parses "def |(); end;" - parses "->::Foo.foo?" parses "->::Foo.foo?" - parses "macro foo(\na = 0\n)\nend" parses "macro foo(\na = 0\n)\nend" - says syntax error on ":bar foo" says syntax error on ":bar foo" - parses "def foo(&); end" parses "def foo(&); end" - parses "a.foo, *a.bar = 1" parses "a.foo, *a.bar = 1" - says syntax error on "def foo(typeof); end" says syntax error on "def foo(typeof); end" - parses ":*" parses ":*" - says syntax error on "Foo(x: T y: U)" says syntax error on "Foo(x: T y: U)" - says syntax error on "b, 1 == 2, a = 4" says syntax error on "b, 1 == 2, a = 4" - parses "case 1\nwhen .foo\n2\nend" parses "case 1\nwhen .foo\n2\nend" - says syntax error on "case 1\nin Int32; 2; else" says syntax error on "case 1\nin Int32; 2; else" - parses "[1] /2" parses "[1] /2" - parses "case\n1\nwhen 1\n2\nend\nif a\nend" parses "case\n1\nwhen 1\n2\nend\nif a\nend" - parses "def foo(@@if); end" parses "def foo(@@if); end" - says syntax error on "def foo @var, █ end" says syntax error on "def foo @var, █ end" - parses "def foo(x : U) : Int32 forall T, U; end" parses "def foo(x : U) : Int32 forall T, U; end" - parses "->foo?" parses "->foo?" - parses "class Foo < self; end" parses "class Foo < self; end" - parses "foo 1, a: 1, b: 2" parses "foo 1, a: 1, b: 2" - parses "2 * (3 + 4)" parses "2 * (3 + 4)" - parses "[1, 2] of Int" parses "[1, 2] of Int" - says syntax error on "next.foo" says syntax error on "next.foo" - parses "{\"foo\": 1}" parses "{\"foo\": 1}" - parses "foo(0, n // 2)" parses "foo(0, n // 2)" - says syntax error on "<<-FOO\n1\nFOO.bar" says syntax error on "<<-FOO\n1\nFOO.bar" - says syntax error on "foo(\"\": 1)" says syntax error on "foo(\"\": 1)" - says syntax error on "next[0]" says syntax error on "next[0]" - parses "lib LibC; fun foo(a : Int**); end" parses "lib LibC; fun foo(a : Int**); end" - says syntax error on "def responds_to?; end" says syntax error on "def responds_to?; end" - says syntax error on "def foo(foo module); end" says syntax error on "def foo(foo module); end" - parses "{% begin %}%i[ %s ]{% end %}" parses "{% begin %}%i[ %s ]{% end %}" - parses "foo.&" parses "foo.&" - parses "return if true" parses "return if true" - parses "def self.=~; end;" parses "def self.=~; end;" - parses "property offsetof : Int32" parses "property offsetof : Int32" - parses "pointerof(@a)" parses "pointerof(@a)" - parses "1;+2" parses "1;+2" - parses "foo ensure 2" parses "foo ensure 2" - says syntax error on "def foo(*args = 1); end" says syntax error on "def foo(*args = 1); end" - parses "lib LibC; type A = B; end" parses "lib LibC; type A = B; end" - says syntax error on "def foo; require \"bar\"; end" says syntax error on "def foo; require \"bar\"; end" - parses "1 &- 2" parses "1 &- 2" - parses "def foo(x @@macro); end" parses "def foo(x @@macro); end" - says syntax error on "def self.!; end" says syntax error on "def self.!; end" - parses "a = 1; a &&= 1" parses "a = 1; a &&= 1" - parses "{% for _, x, _ in y %}body{% end %}" parses "{% for _, x, _ in y %}body{% end %}" - says syntax error on "break > 1" says syntax error on "break > 1" - parses "n !~ 2" parses "n !~ 2" - parses "yield;" parses "yield;" - parses "property when : Int32" parses "property when : Int32" - says syntax error on "macro foo(*x, *y); end" says syntax error on "macro foo(*x, *y); end" - parses "f.x ^= 2" parses "f.x ^= 2" - parses "def /(); end" parses "def /(); end" - parses "foo 1, **bar, &block" parses "foo 1, **bar, &block" - says syntax error on "Hash{\"foo\": 1}" says syntax error on "Hash{\"foo\": 1}" - parses "def self.+(); end;" parses "def self.+(); end;" - says syntax error on "def foo(offsetof); end" says syntax error on "def foo(offsetof); end" - parses "a : Foo[12]" parses "a : Foo[12]" - says syntax error on "case 1 == 1 a; when 2; end" says syntax error on "case 1 == 1 a; when 2; end" - parses "/ /" parses "/ /" - parses "def ==(); end" parses "def ==(); end" - parses "foo **bar" parses "foo **bar" - parses "2 / 3 + 4 / 5" parses "2 / 3 + 4 / 5" - says syntax error on "1 .. next" says syntax error on "1 .. next" - parses "foo = 1; ->foo./(Int32)" parses "foo = 1; ->foo./(Int32)" - parses "->Foo.foo!" parses "->Foo.foo!" - parses "{1.. => 2};" parses "{1.. => 2};" - parses "if foo.responds_to? :foo\nx = 1\nend" parses "if foo.responds_to? :foo\nx = 1\nend" - parses "module : Int32" parses "module : Int32" - says syntax error on "def foo=(a = 1, b = 2); end" says syntax error on "def foo=(a = 1, b = 2); end" - says syntax error on "foo { |(macro)| }" says syntax error on "foo { |(macro)| }" - parses "foo.-(1, 2)" parses "foo.-(1, 2)" - parses "foo(&.as?(T))" parses "foo(&.as?(T))" - says syntax error on "foo { |(asm)| }" says syntax error on "foo { |(asm)| }" - parses "->Foo.[](Int32)" parses "->Foo.[](Int32)" - parses "n + 2" parses "n + 2" - parses "a, b, *c = 1, 2" parses "a, b, *c = 1, 2" - says syntax error on "foo.||()" says syntax error on "foo.||()" - says syntax error on "break when true" says syntax error on "break when true" - parses "case 1\nin .bar?; 2; end" parses "case 1\nin .bar?; 2; end" - says syntax error on "foo { |(def)| }" says syntax error on "foo { |(def)| }" - parses "lib LibC\nfun getchar(a : Int, b : Float) : Int\nend" parses "lib LibC\nfun getchar(a : Int, b : Float) : Int\nend" - parses "def foo(x @@true); end" parses "def foo(x @@true); end" - says syntax error on "def foo(with); end" says syntax error on "def foo(with); end" - says syntax error on "1 .. break" says syntax error on "1 .. break" - parses "begin; 1; rescue Foo; 2; end" parses "begin; 1; rescue Foo; 2; end" - parses "foo%x" parses "foo%x" - parses "begin; / /; end" parses "begin; / /; end" - parses "macro foo;bar{% if x %}body{% else %}body2{%end%}baz;end" parses "macro foo;bar{% if x %}body{% else %}body2{%end%}baz;end" - parses "puts __LINE__" parses "puts __LINE__" - parses "f.x >>= 2" parses "f.x >>= 2" - parses "A = 1" parses "A = 1" - parses "def foo(x @@private); end" parses "def foo(x @@private); end" - parses "Foo(T, {x: X})" parses "Foo(T, {x: X})" - parses "def foo(return foo); end" parses "def foo(return foo); end" - parses "foo(Bar { 1 })" parses "foo(Bar { 1 })" - says syntax error on "foo { |x, (x)| }" says syntax error on "foo { |x, (x)| }" - parses "foo\n\n .bar" parses "foo\n\n .bar" - says syntax error on "def foo(break); end" says syntax error on "def foo(break); end" - parses "a, b = 1, 2 if 3" parses "a, b = 1, 2 if 3" - parses "@[Foo(1, foo: 2)]" parses "@[Foo(1, foo: 2)]" - parses "def foo(x @@extend); end" parses "def foo(x @@extend); end" - says syntax error on "Hash {foo: 1} of Int32 => Int32" says syntax error on "Hash {foo: 1} of Int32 => Int32" - parses "Foo({\"foo bar\": X})" parses "Foo({\"foo bar\": X})" - says syntax error on "foo { |(alias)| }" says syntax error on "foo { |(alias)| }" - says syntax error on "break ^ 1" says syntax error on "break ^ 1" - parses "foo &.[0]" parses "foo &.[0]" - says syntax error on "macro foo(**x, **y)" says syntax error on "macro foo(**x, **y)" - parses "def foo(@@class); end" parses "def foo(@@class); end" - parses "foo.- 1, 2" parses "foo.- 1, 2" - parses "class Foo(*T); end" parses "class Foo(*T); end" - parses "a = 1; (a)/b" parses "a = 1; (a)/b" - says syntax error on "foo { |until| }" says syntax error on "foo { |until| }" - parses "foo = 1; ->foo.>>(Int32)" parses "foo = 1; ->foo.>>(Int32)" - says syntax error on "foo { |x, x| }" says syntax error on "foo { |x, x| }" - parses " macro foo(\n @[Foo]\n id,\n @[Bar] name\n );end" parses " macro foo(\n @[Foo]\n id,\n @[Bar] name\n );end" - parses "f.x <<= 2" parses "f.x <<= 2" - says syntax error on "case {1, 2}; when {3}; 4; end" says syntax error on "case {1, 2}; when {3}; 4; end" - sets correct location of argument in named tuple type sets correct location of argument in named tuple type - parses "def foo(instance_sizeof foo); end" parses "def foo(instance_sizeof foo); end" - says syntax error on "foo { |yield| }" says syntax error on "foo { |yield| }" - says syntax error on "break + 1" says syntax error on "break + 1" - parses "x[{1}]" parses "x[{1}]" - parses "foo = 1; foo &x" parses "foo = 1; foo &x" - parses "def foo(@asm); end" parses "def foo(@asm); end" - parses "(bar {})" parses "(bar {})" - parses "def foo(x @@def); end" parses "def foo(x @@def); end" - parses "->Foo.^(Int32)" parses "->Foo.^(Int32)" - parses "->Foo.foo=" parses "->Foo.foo=" - says syntax error on "enum Foo < UInt16; end" says syntax error on "enum Foo < UInt16; end" - parses "{{ 1 // 2 }}" parses "{{ 1 // 2 }}" - parses "macro foo\n\"\\'\"\nend" parses "macro foo\n\"\\'\"\nend" - parses "1 rescue 2" parses "1 rescue 2" - parses "\"hello \" \\\r\n \"world\"" parses "\"hello \" \\\r\n \"world\"" - says syntax error on "def foo(*x, **x); end" says syntax error on "def foo(*x, **x); end" - parses "foo.>(1, 2)" parses "foo.>(1, 2)" - parses "return 1 if true" parses "return 1 if true" - parses "foo(n >= 2)" parses "foo(n >= 2)" - parses "foo &.block[0] = 1" parses "foo &.block[0] = 1" - parses "def >=(); end" parses "def >=(); end" - says syntax error on "def foo(foo case); end" says syntax error on "def foo(foo case); end" - parses "class Foo\nend" parses "class Foo\nend" - parses "{[] of Foo, Bar::Baz + 2}" parses "{[] of Foo, Bar::Baz + 2}" - parses "@a : Foo" parses "@a : Foo" - parses "%r(\\ )" parses "%r(\\ )" - parses "1 == 2 == 3 == 4" parses "1 == 2 == 3 == 4" - parses "foo = 1; ->foo.*(Int32)" parses "foo = 1; ->foo.*(Int32)" - parses "def foo(x @@var); end" parses "def foo(x @@var); end" - parses "\"hello \#{1}\" \\\n \"\#{2} world\"" parses "\"hello \#{1}\" \\\n \"\#{2} world\"" - parses "foo%r" parses "foo%r" - parses "next 1, 2" parses "next 1, 2" - parses "foo(a: n === 2)" parses "foo(a: n === 2)" - parses "foo.**(1, 2) { 3 }" parses "foo.**(1, 2) { 3 }" - parses "->::Foo.foo" parses "->::Foo.foo" - parses "Set() {1, 2, 3}" parses "Set() {1, 2, 3}" - parses "def self.>=; end;" parses "def self.>=; end;" - parses "{% begin %}%[ %s ]{% end %}" parses "{% begin %}%[ %s ]{% end %}" - parses "->@foo.foo!" parses "->@foo.foo!" - parses "lib LibC\nfun getchar : Int\nend" parses "lib LibC\nfun getchar : Int\nend" - parses "{% begin %}%w< %s >{% end %}" parses "{% begin %}%w< %s >{% end %}" - parses "->@@foo.foo" parses "->@@foo.foo" - parses "macro foo;bar(end: 1);end" parses "macro foo;bar(end: 1);end" - parses "struct Foo; end" parses "struct Foo; end" - parses "do : Int32" parses "do : Int32" - says syntax error on "a.b() = 1" says syntax error on "a.b() = 1" - says syntax error on "def foo(foo struct); end" says syntax error on "def foo(foo struct); end" - parses "def foo(a, &block : Int -> ); end" parses "def foo(a, &block : Int -> ); end" - says syntax error on "return + 1" says syntax error on "return + 1" - parses "1 > 2" parses "1 > 2" - parses "def foo(@[Foo] var : Int32); end" parses "def foo(@[Foo] var : Int32); end" - parses "foo.!.!" parses "foo.!.!" - parses "def foo(x)\n x\nend; foo = 1; b = 2; foo +b" parses "def foo(x)\n x\nend; foo = 1; b = 2; foo +b" - parses "def foo(var : Int*); end" parses "def foo(var : Int*); end" - parses "nil : Int32" parses "nil : Int32" - parses "{[] of Foo, ::Bar::Baz.new}" parses "{[] of Foo, ::Bar::Baz.new}" - parses "def -; end;" parses "def -; end;" - parses "case 1\nwhen .is_a?(T)\n2\nend" parses "case 1\nwhen .is_a?(T)\n2\nend" - parses "->Foo./(Int32)" parses "->Foo./(Int32)" - parses "property abstract : Int32" parses "property abstract : Int32" - says syntax error on "def foo(protected); end" says syntax error on "def foo(protected); end" - parses "foo.>=" parses "foo.>=" - says syntax error on "foo.&&" says syntax error on "foo.&&" - parses "{{ foo &.nil? }}" parses "{{ foo &.nil? }}" - parses "typeof(1)" parses "typeof(1)" - parses "@a, b = 1, 2" parses "@a, b = 1, 2" - parses "enum Foo; protected def foo; 1; end; end" parses "enum Foo; protected def foo; 1; end; end" - parses "lib LibC; struct Foo; x, y, z : Int; end end" parses "lib LibC; struct Foo; x, y, z : Int; end end" - parses "a @b-1\nc" parses "a @b-1\nc" - says syntax error on "foo { |break| }" says syntax error on "foo { |break| }" - parses "property case : Int32" parses "property case : Int32" - says syntax error on "foo(1 2)" says syntax error on "foo(1 2)" - says syntax error on "def foo\nlib\nend" says syntax error on "def foo\nlib\nend" - parses "macro foo;bar{% for x, y in z %}body{% end %}baz;end" parses "macro foo;bar{% for x, y in z %}body{% end %}baz;end" - parses "def self.%; end;" parses "def self.%; end;" - parses "macro foo;bar{% for x in y %}\\ \n body{% end %}baz;end" parses "macro foo;bar{% for x in y %}\\ \n body{% end %}baz;end" - parses "enum Foo; A = 1\ndef foo; 1; end; end" parses "enum Foo; A = 1\ndef foo; 1; end; end" - parses "break *1, 2" parses "break *1, 2" - says syntax error on "def foo(x = 1, y); end" says syntax error on "def foo(x = 1, y); end" - parses "foo = 1; foo a: 1" parses "foo = 1; foo a: 1" - parses "foo = 1; ->foo.>=(Int32)" parses "foo = 1; ->foo.>=(Int32)" - parses "def foo(@nil); end" parses "def foo(@nil); end" - parses "asm(\"nop\" :: \"b\"(1), \"c\"(2) ::)" parses "asm(\"nop\" :: \"b\"(1), \"c\"(2) ::)" - parses "foo(z: 0, a: n &+ 2)" parses "foo(z: 0, a: n &+ 2)" - says syntax error on "next // 1" says syntax error on "next // 1" - parses "\"foo\"" parses "\"foo\"" - parses "property true : Int32" parses "property true : Int32" - parses "def foo(**args)\nargs\nend" parses "def foo(**args)\nargs\nend" - parses "1.[](2)" parses "1.[](2)" - says syntax error on "def foo\nmacro\nend" says syntax error on "def foo\nmacro\nend" - parses "foo(n + 2)" parses "foo(n + 2)" - says syntax error on "def foo(x, **x); end" says syntax error on "def foo(x, **x); end" - parses "1 \\\n + 2" parses "1 \\\n + 2" - parses "1 >> 2" parses "1 >> 2" - says syntax error on "def foo(\"bar\");end" says syntax error on "def foo(\"bar\");end" - parses "property fun : Int32" parses "property fun : Int32" - says syntax error on "foo { |alias| }" says syntax error on "foo { |alias| }" - parses "a = 1; pointerof(a)" parses "a = 1; pointerof(a)" - says syntax error on "@:Foo" says syntax error on "@:Foo" - parses "foo(0, n / 2)" parses "foo(0, n / 2)" - parses "foo.=== 1, 2" parses "foo.=== 1, 2" - says syntax error on "1 ... next" says syntax error on "1 ... next" - says syntax error on "def foo?=(x); end" says syntax error on "def foo?=(x); end" - parses "def foo(yield foo); end" parses "def foo(yield foo); end" - says syntax error on "$foo" says syntax error on "$foo" - parses "def foo(x, **args, &block)\n1\nend" parses "def foo(x, **args, &block)\n1\nend" - parses "n ** 2" parses "n ** 2" - parses "{\n1,\n2\n}" parses "{\n1,\n2\n}" - says syntax error on " [1, 2, 3 end" says syntax error on " [1, 2, 3 end" - parses "foo.nil?( )" parses "foo.nil?( )" - parses "{% begin %}%x( %s ){% end %}" parses "{% begin %}%x( %s ){% end %}" - parses "def foo(var : Int32 -> = 1); end" parses "def foo(var : Int32 -> = 1); end" - parses "puts {{*1}}" parses "puts {{*1}}" - parses "def foo(x @@offsetof); end" parses "def foo(x @@offsetof); end" - parses "foo(bar:a, baz:b)" parses "foo(bar:a, baz:b)" - parses "lib LibC; struct Foo; x : Int*; end end" parses "lib LibC; struct Foo; x : Int*; end end" - parses "sizeof(\n Int32\n)" parses "sizeof(\n Int32\n)" - says syntax error on "case when .foo? then 1; end" says syntax error on "case when .foo? then 1; end" - parses "def self.===(); end;" parses "def self.===(); end;" - says syntax error on "1 if break" says syntax error on "1 if break" - parses "n // 2" parses "n // 2" - parses "foo = 1; b = 2; foo +b" parses "foo = 1; b = 2; foo +b" - parses "foo = 1; ->foo.[]=(Int32)" parses "foo = 1; ->foo.[]=(Int32)" - parses "<<-HERE\n One \\n Two\n Zero\n HERE" parses "<<-HERE\n One \\n Two\n Zero\n HERE" - parses "def foo(x @@lib); end" parses "def foo(x @@lib); end" - parses "def foo(@if); end" parses "def foo(@if); end" - says syntax error on "foo { |require| }" says syntax error on "foo { |require| }" - parses "+ 1" parses "+ 1" - parses "until true; end;" parses "until true; end;" - says syntax error on "def foo(foo true); end" says syntax error on "def foo(foo true); end" - parses "def **(); end" parses "def **(); end" - parses "def foo(a, &block : self -> self); end" parses "def foo(a, &block : self -> self); end" - parses "def foo(x @@yield); end" parses "def foo(x @@yield); end" - says syntax error on "def foo; A = 1; end" says syntax error on "def foo; A = 1; end" - parses "def foo(@struct); end" parses "def foo(@struct); end" - says syntax error on "def foo(x @@x); 1; end" says syntax error on "def foo(x @@x); 1; end" - parses "1 + 2" parses "1 + 2" - parses "foo(0, n == 2)" parses "foo(0, n == 2)" - says syntax error on "def foo(lib); end" says syntax error on "def foo(lib); end" - parses "_, _ = 1, 2" parses "_, _ = 1, 2" - parses "foo(a: n &+ 2)" parses "foo(a: n &+ 2)" - says syntax error on "break < 1" says syntax error on "break < 1" - parses "1 * 2" parses "1 * 2" - parses "{% begin %}%Q| %s |{% end %}" parses "{% begin %}%Q| %s |{% end %}" - parses "class Foo(T1); end" parses "class Foo(T1); end" - parses "a : Foo()*" parses "a : Foo()*" - parses "a = 1; a %=\n1" parses "a = 1; a %=\n1" - parses "Foo(T, 1)" parses "Foo(T, 1)" - parses "foo(1.., 2)" parses "foo(1.., 2)" - parses "break if true" parses "break if true" - says syntax error on "1 ... return" says syntax error on "1 ... return" - parses "{% a = 1 %}" parses "{% a = 1 %}" - says syntax error on "def foo(macro); end" says syntax error on "def foo(macro); end" - parses "def &*(); end" parses "def &*(); end" - parses "a = 1; class Foo; @x = a; end" parses "a = 1; class Foo; @x = a; end" - parses "[..2]" parses "[..2]" - parses "<<-HERE\n \#{1} \\n \#{2}\n HERE" parses "<<-HERE\n \#{1} \\n \#{2}\n HERE" - parses "a = 1; a **=\n1" parses "a = 1; a **=\n1" - says syntax error on "foo { |abstract| }" says syntax error on "foo { |abstract| }" - parses "1 << 2" parses "1 << 2" - parses "def foo(x @@nil); end" parses "def foo(x @@nil); end" - parses "foo(z: 0, a: n === 2)" parses "foo(z: 0, a: n === 2)" - parses "->() : Int32 do end" parses "->() : Int32 do end" - parses "when : Int32" parses "when : Int32" - parses "lib LibC\nfun getchar(Int, Float)\nend" parses "lib LibC\nfun getchar(Int, Float)\nend" - says syntax error on "next ? 1 : 2" says syntax error on "next ? 1 : 2" - parses "foo(a: 1, b: 2)" parses "foo(a: 1, b: 2)" - says syntax error on "lib LibC\n$Errno : Int32\nend" says syntax error on "lib LibC\n$Errno : Int32\nend" - says syntax error on "def foo &block ; end" says syntax error on "def foo &block ; end" - parses "foo.!" parses "foo.!" - parses "foo.>=(1, 2) { 3 }" parses "foo.>=(1, 2) { 3 }" - parses "a = /=/" parses "a = /=/" - says syntax error on "next .. 1" says syntax error on "next .. 1" - parses "def foo(@@while); end" parses "def foo(@@while); end" - says syntax error on "return[]" says syntax error on "return[]" - parses "macro %;end" parses "macro %;end" - says syntax error on "def foo(class); end" says syntax error on "def foo(class); end" - says syntax error on "def foo(foo class); end" says syntax error on "def foo(foo class); end" - parses "foo(z: 0, a: n | 2)" parses "foo(z: 0, a: n | 2)" - parses "def self.==(); end;" parses "def self.==(); end;" - parses "foo(&block)" parses "foo(&block)" - parses "foo(..2)" parses "foo(..2)" - parses "case {1}\nin {Foo(Int32)}; 2; end" parses "case {1}\nin {Foo(Int32)}; 2; end" - parses "->foo" parses "->foo" - parses "foo(a: n =~ 2)" parses "foo(a: n =~ 2)" - parses "def foo(@extend); end" parses "def foo(@extend); end" - parses "1 / 2" parses "1 / 2" - parses "struct : Int32" parses "struct : Int32" - parses "def self.*(); end;" parses "def self.*(); end;" - parses "(1)\nif true; end" parses "(1)\nif true; end" - parses "a = / /" parses "a = / /" - parses "def &+(); end" parses "def &+(); end" - parses "def foo(@@return); end" parses "def foo(@@return); end" - parses "@@a, b = 1, 2" parses "@@a, b = 1, 2" - parses "1 if 3" parses "1 if 3" - says syntax error on "def foo:String\nend" says syntax error on "def foo:String\nend" - parses "property extend : Int32" parses "property extend : Int32" - says syntax error on "def foo(&a foo); end" says syntax error on "def foo(&a foo); end" - parses "a = 1\nfoo -a" parses "a = 1\nfoo -a" - says syntax error on "def foo(**a foo); end" says syntax error on "def foo(**a foo); end" - parses "enum Foo; private def foo; 1; end; end" parses "enum Foo; private def foo; 1; end; end" - parses "enum Foo::Bar; A = 1; end" parses "enum Foo::Bar; A = 1; end" - parses "macro foo;bar{% if x %}body{% elsif y %}body2{%end%}baz;end" parses "macro foo;bar{% if x %}body{% elsif y %}body2{%end%}baz;end" - says syntax error on "self = 1" says syntax error on "self = 1" - parses "def foo(@var); 1; end" parses "def foo(@var); 1; end" - parses "def foo; a = 1; a {}; end" parses "def foo; a = 1; a {}; end" - parses "a = 1; pointerof(a)" parses "a = 1; pointerof(a)" - says syntax error on "asm(\"nop\" :::: \"\#{volatile}\")" says syntax error on "asm(\"nop\" :::: \"\#{volatile}\")" - parses "def foo(x @while); end" parses "def foo(x @while); end" - parses "@@foo" parses "@@foo" - parses "foo &.as(T).bar" parses "foo &.as(T).bar" - parses "(baz; bar do\nend)" parses "(baz; bar do\nend)" - parses "foo(z: 0, a: n // 2)" parses "foo(z: 0, a: n // 2)" - parses "x = 1 rescue 2" parses "x = 1 rescue 2" - parses "def foo; with a yield 1; end" parses "def foo; with a yield 1; end" - parses "case {1}\nin {false}; 2; end" parses "case {1}\nin {false}; 2; end" - parses "f.x = Foo.new" parses "f.x = Foo.new" - parses "macro []?;end" parses "macro []?;end" - says syntax error on "{1, 2 3}" says syntax error on "{1, 2 3}" - says syntax error on "def foo\ninclude\nend" says syntax error on "def foo\ninclude\nend" - parses "foo do |a|; 1; end" parses "foo do |a|; 1; end" - parses "-@foo" parses "-@foo" - says syntax error on "def foo\nabstract\nend" says syntax error on "def foo\nabstract\nend" - parses "def foo(\n&block\n); end" parses "def foo(\n&block\n); end" - parses "foo.*(1, 2)" parses "foo.*(1, 2)" - parses "@@a : Foo = 1" parses "@@a : Foo = 1" - parses "foo.<(1, 2) { 3 }" parses "foo.<(1, 2) { 3 }" - says syntax error on "foo(**bar, *x)" says syntax error on "foo(**bar, *x)" - parses ":<" parses ":<" - parses "foo % q()" parses "foo % q()" - parses "foo.bar(1, 2)" parses "foo.bar(1, 2)" - parses "def foo(@@fun); end" parses "def foo(@@fun); end" - parses "foo(a: n >> 2)" parses "foo(a: n >> 2)" - parses "case\nwhen true\n1\nend" parses "case\nwhen true\n1\nend" - says syntax error on "b! = 1" says syntax error on "b! = 1" - parses "/foo/x" parses "/foo/x" - parses "foo(x) do\n//\nend" parses "foo(x) do\n//\nend" - parses "foo.=~ do end" parses "foo.=~ do end" - parses "foo = 1; foo(+1)" parses "foo = 1; foo(+1)" - parses "foo = 1; ->foo.>(Int32)" parses "foo = 1; ->foo.>(Int32)" - parses "1 -2" parses "1 -2" - parses "property next : Int32" parses "property next : Int32" - parses "macro foo;%var unless true;end" parses "macro foo;%var unless true;end" - parses "def <=(); end" parses "def <=(); end" - says syntax error on "@[Foo(\"\": 1)]" says syntax error on "@[Foo(\"\": 1)]" - parses ":<=>" parses ":<=>" - parses "def foo(x @typeof); end" parses "def foo(x @typeof); end" - parses "return;" parses "return;" - parses "foo(a: n > 2)" parses "foo(a: n > 2)" - parses "property instance_sizeof : Int32" parses "property instance_sizeof : Int32" - sets correct location of annotation in enum sets correct location of annotation in enum - parses "asm(\"bl trap\" :::: \"unwind\")" parses "asm(\"bl trap\" :::: \"unwind\")" - says syntax error on "foo(**bar, 1)" says syntax error on "foo(**bar, 1)" - parses "macro foo;if %var;true;end;end" parses "macro foo;if %var;true;end;end" - says syntax error on "Foo{one: :two, three: :four}" says syntax error on "Foo{one: :two, three: :four}" - parses "foo(n >> 2)" parses "foo(n >> 2)" - says syntax error on "def foo(foo extend); end" says syntax error on "def foo(foo extend); end" - parses "foo%q" parses "foo%q" - parses "a = 1; a &*=\n1" parses "a = 1; a &*=\n1" - parses "def foo(x, *y); 1; end" parses "def foo(x, *y); 1; end" - parses "{a: 1, b: 2}" parses "{a: 1, b: 2}" - parses "enum Foo : UInt16; end" parses "enum Foo : UInt16; end" - parses ":**" parses ":**" - parses "def &(); end;" parses "def &(); end;" - parses "-1.0" parses "-1.0" - says syntax error on "foo { |begin| }" says syntax error on "foo { |begin| }" - parses "macro /;end" parses "macro /;end" - parses "foo *bar" parses "foo *bar" - says syntax error on "->::@@foo.foo" says syntax error on "->::@@foo.foo" - parses "foo.responds_to? :foo" parses "foo.responds_to? :foo" - parses "!1" parses "!1" - says syntax error on "return &** 1" says syntax error on "return &** 1" - parses "->Foo.&*(Int32)" parses "->Foo.&*(Int32)" - parses "def foo(@next); end" parses "def foo(@next); end" - parses "def foo(var : Char[256]); end" parses "def foo(var : Char[256]); end" - says syntax error on "foo[1] = break" says syntax error on "foo[1] = break" - parses "macro foo\neenum\nend" parses "macro foo\neenum\nend" - parses "\n class Foo\n def bar\n print as Foo\n end\n end\n " parses "\n class Foo\n def bar\n print as Foo\n end\n end\n " - says syntax error on "foo.&&()" says syntax error on "foo.&&()" - parses "{%\na = 1\n%}" parses "{%\na = 1\n%}" - says syntax error on "foo { |instance_sizeof| }" says syntax error on "foo { |instance_sizeof| }" - parses "foo &.each {\n}" parses "foo &.each {\n}" - parses "asm(\"nop\" :: \"b\"(1), \"c\"(2))" parses "asm(\"nop\" :: \"b\"(1), \"c\"(2))" - parses "def foo(x, *args, y = 2); 1; end" parses "def foo(x, *args, y = 2); 1; end" - says syntax error on "enum Foo\n A, B, C\nend\n" says syntax error on "enum Foo\n A, B, C\nend\n" - parses "foo(0, n =~ 2)" parses "foo(0, n =~ 2)" - parses "def foo(@@alias); end" parses "def foo(@@alias); end" - says syntax error on "return.foo" says syntax error on "return.foo" - parses "{{ foo.nil?(foo) }}" parses "{{ foo.nil?(foo) }}" - parses "def foo(x @@in); end" parses "def foo(x @@in); end" - parses "puts {{1}}" parses "puts {{1}}" - parses "call ->foo" parses "call ->foo" - parses "foo &.nil?" parses "foo &.nil?" - parses "\"hello \#{1}\" \\\r\n \"\#{2} world\"" parses "\"hello \#{1}\" \\\r\n \"\#{2} world\"" - parses "macro foo\n <<-FOO\n \#{ %var }\n FOO\nend" parses "macro foo\n <<-FOO\n \#{ %var }\n FOO\nend" - parses "def self.**(); end;" parses "def self.**(); end;" - parses "foo.!( )" parses "foo.!( )" - says syntax error on "asm(\"\" : 1)" says syntax error on "asm(\"\" : 1)" - parses "def self.==; end;" parses "def self.==; end;" - says syntax error on "1 if next" says syntax error on "1 if next" - parses "include : Int32" parses "include : Int32" - parses "f.x -= 2" parses "f.x -= 2" - says syntax error on "next << 1" says syntax error on "next << 1" - parses "def foo(x = __DIR__); end" parses "def foo(x = __DIR__); end" - says syntax error on "1 unless next" says syntax error on "1 unless next" - says syntax error on "a, b, c, d, *e = 1, 2, 3" says syntax error on "a, b, c, d, *e = 1, 2, 3" - says syntax error on "foo { |(return)| }" says syntax error on "foo { |(return)| }" - parses "a.b/2" parses "a.b/2" - says syntax error on "next.as(Int32)" says syntax error on "next.as(Int32)" - parses ":[]" parses ":[]" - parses "foo { |a, b| 1 }" parses "foo { |a, b| 1 }" - says syntax error on "def foo(x :Int32); end" says syntax error on "def foo(x :Int32); end" - says syntax error on "def as?; end" says syntax error on "def as?; end" - parses "property yield : Int32" parses "property yield : Int32" - parses "return {1, 2}" parses "return {1, 2}" - parses "def foo(a, &block : *Int -> ); end" parses "def foo(a, &block : *Int -> ); end" - says syntax error on "return ** 1" says syntax error on "return ** 1" - parses "def foo(x @@enum); end" parses "def foo(x @@enum); end" - parses "call(foo.as Bar, Baz)" parses "call(foo.as Bar, Baz)" - parses "a\nwhile / /\n/ /\nend" parses "a\nwhile / /\n/ /\nend" - parses "macro ==;end" parses "macro ==;end" - parses "foo(\n1\n)" parses "foo(\n1\n)" - says syntax error on "break[]" says syntax error on "break[]" - parses "foo(n =~ 2)" parses "foo(n =~ 2)" - parses "foo(z: 0, a: n <= 2)" parses "foo(z: 0, a: n <= 2)" - parses "def foo(x @@begin); end" parses "def foo(x @@begin); end" - parses "foo(&.bar.baz)" parses "foo(&.bar.baz)" - says syntax error on "def self.is_a?; end" says syntax error on "def self.is_a?; end" - parses "property until : Int32" parses "property until : Int32" - parses "case 1; when 2 then /foo/; end" parses "case 1; when 2 then /foo/; end" - parses "abstract def foo : Int32" parses "abstract def foo : Int32" - parses "->Foo.===(Int32)" parses "->Foo.===(Int32)" - says syntax error on "*a" says syntax error on "*a" - says syntax error on "foo { |(fun)| }" says syntax error on "foo { |(fun)| }" - says syntax error on "def foo(**args, **args2); end" says syntax error on "def foo(**args, **args2); end" - parses "-> { }" parses "-> { }" - says syntax error on "def as; end" says syntax error on "def as; end" - parses "macro <=;end" parses "macro <=;end" - says syntax error on "foo { |(with)| }" says syntax error on "foo { |(with)| }" - parses "a : Foo()[12]" parses "a : Foo()[12]" - parses "{% unless 1\n x\nend %}" parses "{% unless 1\n x\nend %}" - parses "{% begin %}%x< %s >{% end %}" parses "{% begin %}%x< %s >{% end %}" - parses "def foo(&block :\n Int ->); end" parses "def foo(&block :\n Int ->); end" - parses "def !=(); end;" parses "def !=(); end;" - parses "def foo(module foo); end" parses "def foo(module foo); end" - parses "include Foo" parses "include Foo" - parses "def self.<=(); end;" parses "def self.<=(); end;" - says syntax error on "def foo(foo nil); end" says syntax error on "def foo(foo nil); end" - parses "break *1" parses "break *1" - sets correct location of private method in enum sets correct location of private method in enum - parses "foo(&.as(T))" parses "foo(&.as(T))" - parses "foo.bar 1, 2" parses "foo.bar 1, 2" - parses "foo(\n &.block\n)" parses "foo(\n &.block\n)" - parses "def foo(@private); end" parses "def foo(@private); end" - parses "foo %x" parses "foo %x" - parses "class Foo\ndef foo; end; end" parses "class Foo\ndef foo; end; end" - says syntax error on "def foo(x : U) forall U,; end" says syntax error on "def foo(x : U) forall U,; end" - parses "->@foo.foo" parses "->@foo.foo" - parses "def self.[]; end" parses "def self.[]; end" - says syntax error on "nil foo" says syntax error on "nil foo" - parses "foo.[0]" parses "foo.[0]" - parses "foo.responds_to?(:foo)" parses "foo.responds_to?(:foo)" - parses "->Foo.=~(Int32)" parses "->Foo.=~(Int32)" - says syntax error on "self += 1" says syntax error on "self += 1" - parses "foo.is_a? Const" parses "foo.is_a? Const" - parses "enum Foo; A\nB; C\nD = 1; end" parses "enum Foo; A\nB; C\nD = 1; end" - parses "begin : Int32" parses "begin : Int32" - parses "foo.- do end" parses "foo.- do end" - parses "def foo(var); end" parses "def foo(var); end" - parses "def foo(&\n); end" parses "def foo(&\n); end" - parses "{% begin %}%q< %s >{% end %}" parses "{% begin %}%q< %s >{% end %}" - parses "begin; 1; rescue ex; 2; end; ex" parses "begin; 1; rescue ex; 2; end; ex" - says syntax error on "next[0]= 1" says syntax error on "next[0]= 1" - parses "def []=(*args, **opts, &); end" parses "def []=(*args, **opts, &); end" - parses "abstract def foo(x) : Int32" parses "abstract def foo(x) : Int32" - says syntax error on "def foo=(a,b); end" says syntax error on "def foo=(a,b); end" - parses "1 =~ 2" parses "1 =~ 2" - parses "foo.bar do end" parses "foo.bar do end" - parses "@[Foo(1)]" parses "@[Foo(1)]" - parses "def self.&(); end;" parses "def self.&(); end;" - says syntax error on "def foo():String\nend" says syntax error on "def foo():String\nend" - says syntax error on "->(x y) { }" says syntax error on "->(x y) { }" - says syntax error on "return === 1" says syntax error on "return === 1" - says syntax error on "macro as; end" says syntax error on "macro as; end" - parses "+1.0" parses "+1.0" - parses "foo.* 1, 2" parses "foo.* 1, 2" - parses "{% if 1; 2; end %}" parses "{% if 1; 2; end %}" - parses "def foo(enum foo); end" parses "def foo(enum foo); end" - parses "def foo(var : Int -> Double); end" parses "def foo(var : Int -> Double); end" - parses "%r(foo(bar))" parses "%r(foo(bar))" - parses "a ? 1 :\n b ? 2 :\n c ? 3\n : 0" parses "a ? 1 :\n b ? 2 :\n c ? 3\n : 0" - parses "{% begin %}%i( %s ){% end %}" parses "{% begin %}%i( %s ){% end %}" - parses "foo { |(_, c, )| c }" parses "foo { |(_, c, )| c }" - parses "elsif : Int32" parses "elsif : Int32" - parses "foo.& do end" parses "foo.& do end" - parses "foo.==(1, 2)" parses "foo.==(1, 2)" - parses "macro foo(a, @[Foo] &block);end" parses "macro foo(a, @[Foo] &block);end" - parses "1 -2.0" parses "1 -2.0" - parses "foo(/ /)" parses "foo(/ /)" - parses "foo(n &* 2)" parses "foo(n &* 2)" - parses "foo(n &- 2)" parses "foo(n &- 2)" - parses "a\nunless / /\n/ /\nelse\n/ /\nend" parses "a\nunless / /\n/ /\nelse\n/ /\nend" - parses "-> do end" parses "-> do end" - parses "*a, b = 1, 2, 3, 4" parses "*a, b = 1, 2, 3, 4" - parses "foo(z: 0, a: n & 2)" parses "foo(z: 0, a: n & 2)" - parses "macro !=;end" parses "macro !=;end" - parses "Foo({X, Y,})" parses "Foo({X, Y,})" - parses "a ? 1\n : b" parses "a ? 1\n : b" - parses ":foo?" parses ":foo?" - says syntax error on "def foo(foo return); end" says syntax error on "def foo(foo return); end" - parses "def foo(x @@asm); end" parses "def foo(x @@asm); end" - parses "a[0], a[1] = 1, 2" parses "a[0], a[1] = 1, 2" - says syntax error on "foo { |(require)| }" says syntax error on "foo { |(require)| }" - parses "case / /\nwhen / /\n/ /\nelse\n/ /\nend" parses "case / /\nwhen / /\n/ /\nelse\n/ /\nend" - parses "def foo(x, *, y); 1; end" parses "def foo(x, *, y); 1; end" - parses "def ===(*args, **opts, &); end" parses "def ===(*args, **opts, &); end" - parses "foo % w()" parses "foo % w()" - says syntax error on "until next; end" says syntax error on "until next; end" - parses "a/b" parses "a/b" - says syntax error on "{\n}" says syntax error on "{\n}" - parses "case {1}\nin {Int32.class}; 2; end" parses "case {1}\nin {Int32.class}; 2; end" - parses ":===" parses ":===" - parses "foo &.bar.baz" parses "foo &.bar.baz" - says syntax error on "def foo\nalias\nend" says syntax error on "def foo\nalias\nend" - parses "a = 1; a += 1" parses "a = 1; a += 1" - parses "foo(n * 2)" parses "foo(n * 2)" - parses "alignof(X)" parses "alignof(X)" - parses "a, b, *c = 1" parses "a, b, *c = 1" - sets correct location of instance variable in proc pointer sets correct location of instance variable in proc pointer - parses "<<-'HERE'\n hello \\n world\n \#{1}\n HERE" parses "<<-'HERE'\n hello \\n world\n \#{1}\n HERE" - parses "def self.|; end;" parses "def self.|; end;" - parses "x[a: 1, b: 2,]" parses "x[a: 1, b: 2,]" - parses "def foo(@[Foo] var); end" parses "def foo(@[Foo] var); end" - parses "@foo/2" parses "@foo/2" - parses "def foo(x = / /); end" parses "def foo(x = / /); end" - parses "property unless : Int32" parses "property unless : Int32" - says syntax error on "case 1\nin 1; 2" says syntax error on "case 1\nin 1; 2" - parses "(foo bar do\nend)" parses "(foo bar do\nend)" - parses "a = 1; a &= 1" parses "a = 1; a &= 1" - parses "a; unless / /; / /; else; / /; end" parses "a; unless / /; / /; else; / /; end" - parses "\"\#{1\n}\"" parses "\"\#{1\n}\"" - parses "a[], a[] = 1, 2" parses "a[], a[] = 1, 2" - parses "foo(z: 0, a: n < 2)" parses "foo(z: 0, a: n < 2)" - says syntax error on "def foo(case); end" says syntax error on "def foo(case); end" - parses "a.b **=\n1" parses "a.b **=\n1" - parses "foo(bar { })" parses "foo(bar { })" - parses "def foo(var : Int**); end" parses "def foo(var : Int**); end" - parses "foo(\"foo bar\": 1, \"baz\": 2)" parses "foo(\"foo bar\": 1, \"baz\": 2)" - says syntax error on "-> :Int32 { }" says syntax error on "-> :Int32 { }" - says syntax error on "a = break" says syntax error on "a = break" - parses "puts ::foo" parses "puts ::foo" - parses "{1, 2, 3}" parses "{1, 2, 3}" - parses "return {1 => 2}" parses "return {1 => 2}" - parses "n | 2" parses "n | 2" - parses "foo(0, n * 2)" parses "foo(0, n * 2)" - parses "foo ..2" parses "foo ..2" - says syntax error on "a {}, b = 1" says syntax error on "a {}, b = 1" - parses "\"hello \\\n world\"" parses "\"hello \\\n world\"" - says syntax error on "->(x : Int32, x : Int32) {}" says syntax error on "->(x : Int32, x : Int32) {}" - parses "(/ /)" parses "(/ /)" - parses "def foo(x @yield); end" parses "def foo(x @yield); end" - parses "x = 0; a, b = x += 1" parses "x = 0; a, b = x += 1" - says syntax error on "'a' foo" says syntax error on "'a' foo" - says syntax error on "foo { |(while)| }" says syntax error on "foo { |(while)| }" - says syntax error on "a = 1; a += break" says syntax error on "a = 1; a += break" - parses "Set {1, 2, 3}" parses "Set {1, 2, 3}" - parses ":%" parses ":%" - parses "def &-(); end" parses "def &-(); end" - says syntax error on "macro nil?; end" says syntax error on "macro nil?; end" - parses ":>=" parses ":>=" - parses "def foo(*y : *T); 1; end" parses "def foo(*y : *T); 1; end" - says syntax error on "foo[next]" says syntax error on "foo[next]" - parses "\"hello \\\r\n world\"" parses "\"hello \\\r\n world\"" - parses "def foo(@while); end" parses "def foo(@while); end" - says syntax error on "foo { |(false)| }" says syntax error on "foo { |(false)| }" - parses "def <=(*args, **opts, &); end" parses "def <=(*args, **opts, &); end" - parses "n * 2" parses "n * 2" - says syntax error on "foo { |(protected)| }" says syntax error on "foo { |(protected)| }" - parses "a()/3" parses "a()/3" - parses "def foo(a, &block : Int, Float -> Double); end" parses "def foo(a, &block : Int, Float -> Double); end" - says syntax error on "macro is_a?; end" says syntax error on "macro is_a?; end" - parses "foo.<=" parses "foo.<=" - says syntax error on "if 1\n foo 1,\nend" says syntax error on "if 1\n foo 1,\nend" - parses "a == / /" parses "a == / /" - says syntax error on "def foo(foo sizeof); end" says syntax error on "def foo(foo sizeof); end" - parses "lib LibC; fun foo(a : ::B, ::C -> ::D); end" parses "lib LibC; fun foo(a : ::B, ::C -> ::D); end" - parses "enum Foo; A = 1\ndef self.foo; 1; end\nend" parses "enum Foo; A = 1\ndef self.foo; 1; end\nend" - parses "foo.[]= do end" parses "foo.[]= do end" - parses "foo.^(1, 2) { 3 }" parses "foo.^(1, 2) { 3 }" - says syntax error on "lib Foo%end" says syntax error on "lib Foo%end" - parses "alias : Int32" parses "alias : Int32" - parses "def foo(@var = 1); 1; end" parses "def foo(@var = 1); 1; end" - parses "offsetof : Int32" parses "offsetof : Int32" - says syntax error on "foo { |(next)| }" says syntax error on "foo { |(next)| }" - parses "n < 2" parses "n < 2" - parses "->@@foo.foo!" parses "->@@foo.foo!" - says syntax error on "foo { |sizeof| }" says syntax error on "foo { |sizeof| }" - parses "foo.+" parses "foo.+" - parses "case 1\nin Int32; 2; end" parses "case 1\nin Int32; 2; end" -Normalize: proc pointer - normalizes proc pointer with parameters, without object normalizes proc pointer with parameters, without object - normalizes proc pointer with ivar receiver normalizes proc pointer with ivar receiver - normalizes proc pointer with global const receiver normalizes proc pointer with global const receiver - normalizes proc pointer without object normalizes proc pointer without object - normalizes proc pointer with const receiver normalizes proc pointer with const receiver - normalizes proc pointer with variable receiver normalizes proc pointer with variable receiver - normalizes proc pointer of global call normalizes proc pointer of global call - normalizes proc pointer with cvar receiver normalizes proc pointer with cvar receiver -Call errors - says type mismatch for positional argument with two options says type mismatch for positional argument with two options - says type mismatch for symbol against enum, named argument case says type mismatch for symbol against enum, named argument case - says wrong number of arguments even if other overloads don't match by block says wrong number of arguments even if other overloads don't match by block - says type mismatch for symbol against enum (did you mean) says type mismatch for symbol against enum (did you mean) - says type mismatch for positional argument with three options says type mismatch for positional argument with three options - says not expected to be invoked with a block says not expected to be invoked with a block - says missing named arguments says missing named arguments - says missing named argument says missing named argument - says type mismatch for named argument says type mismatch for named argument - says type mismatch for positional argument even if there are overloads that don't match says type mismatch for positional argument even if there are overloads that don't match - says type mismatch for positional argument says type mismatch for positional argument - errors on argument if more types are given than expected, shows all expected types errors on argument if more types are given than expected, shows all expected types - replaces free variables in positional argument replaces free variables in positional argument - method signatures in error traces - expands double splat argument, more elements expands double splat argument, more elements - includes named arguments includes named arguments - expands positional and single splat argument, empty tuple expands positional and single splat argument, empty tuple - expands double splat argument, empty named tuple expands double splat argument, empty named tuple - expands single splat argument, more elements expands single splat argument, more elements - expands positional and double splat argument, more elements expands positional and double splat argument, more elements - expands positional and single splat argument expands positional and single splat argument - includes named argument includes named argument - includes positional and named argument includes positional and named argument - expands positional and double splat argument, empty named tuple expands positional and double splat argument, empty named tuple - expands positional and double splat argument expands positional and double splat argument - uses `T.method` instead of `T:module#method` uses `T.method` instead of `T:module#method` - expands single splat argument, empty tuple expands single splat argument, empty tuple - expands positional and single splat argument, more elements expands positional and single splat argument, more elements - expands double splat argument expands double splat argument - expands single splat argument expands single splat argument - uses `T.method` instead of `T.class#method` uses `T.method` instead of `T.class#method` - replaces generic type var in positional argument replaces generic type var in positional argument - says no parameter named says no parameter named - errors on argument if argument matches in all overloads but with different types in other arguments errors on argument if argument matches in all overloads but with different types in other arguments - says no parameters named says no parameters named - says argument already specified says argument already specified - says expected to be invoked with a block says expected to be invoked with a block - errors on argument if more types are given than expected errors on argument if more types are given than expected - replaces free variables in named argument replaces free variables in named argument - says wrong number of arguments (to few arguments) says wrong number of arguments (to few arguments) - says type mismatch for symbol against enum (list all possibilities when 10 or less) says type mismatch for symbol against enum (list all possibilities when 10 or less) - replaces generic type var in named argument replaces generic type var in named argument -Code gen: automatic cast - casts literal integer (Int32 -> Float32) casts literal integer (Int32 -> Float32) - casts Symbol to Enum in ivar type declaration casts Symbol to Enum in ivar type declaration - casts literal float (Float32 -> Float64) casts literal float (Float32 -> Float64) - casts literal integer (Int32 -> Float64) casts literal integer (Int32 -> Float64) - casts literal integer (Int64 -> Int32, ok) casts literal integer (Int64 -> Int32, ok) - does multidispatch with automatic casting (1) (#8217) does multidispatch with automatic casting (1) (#8217) - doesn't autocast number on union (#8655) doesn't autocast number on union (#8655) - casts Int32 to Int64 in ivar assignment casts Int32 to Int64 in ivar assignment - casts symbol literal to enum casts symbol literal to enum - casts Int32 to Int64 in cvar type declaration casts Int32 to Int64 in cvar type declaration - casts literal float (Float64 -> Float32) casts literal float (Float64 -> Float32) - casts integer variable to larger type (#9565) casts integer variable to larger type (#9565) - casts Int32 to Int64 in ivar type declaration casts Int32 to Int64 in ivar type declaration - casts Int32 to Int64 in lvar assignment casts Int32 to Int64 in lvar assignment - casts Int32 to Int64 in ivar type declaration in generic casts Int32 to Int64 in ivar type declaration in generic - casts Int32 -> Int64 in arg restriction casts Int32 -> Int64 in arg restriction - casts Int32 to Int64 in cvar assignment casts Int32 to Int64 in cvar assignment - does multidispatch with automatic casting (3) does multidispatch with automatic casting (3) - does multidispatch with automatic casting (2) (#8217) does multidispatch with automatic casting (2) (#8217) - casts Symbol to Enum in ivar assignment casts Symbol to Enum in ivar assignment - casts literal integer (Int32 -> Int64) casts literal integer (Int32 -> Int64) -Code gen: debug - codegens lib union (#7335) codegens lib union (#7335) - has debug info in closure inside if (#5593) has debug info in closure inside if (#5593) - inlines instance var access through getter in debug mode inlines instance var access through getter in debug mode - codegens correct debug info for untyped expression (#4007 and #4008) codegens correct debug info for untyped expression (#4007 and #4008) - doesn't emit debug info for unused variable declarations (#9882) doesn't emit debug info for unused variable declarations (#9882) - stores and restores debug location after jumping to main (#6920) stores and restores debug location after jumping to main (#6920) - doesn't fail on constant read calls (#11416) doesn't fail on constant read calls (#11416) - correctly restores debug location after fun change (#4254) correctly restores debug location after fun change (#4254) - codegens correct debug info for new with custom allocate (#3945) codegens correct debug info for new with custom allocate (#3945) - doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals doesn't fail on splat expansions inside array-like literals - stores and restores debug location after jumping to main (3) stores and restores debug location after jumping to main (3) - codegens extern union (#7335) codegens extern union (#7335) - doesn't emit incorrect debug info for closured self doesn't emit incorrect debug info for closured self - codegens abstract struct (#3578) codegens abstract struct (#3578) - stores and restores debug location after jumping to main (2) stores and restores debug location after jumping to main (2) - has correct debug location after constant initialization in call with block (#4719) has correct debug location after constant initialization in call with block (#4719) -Crystal::Repl::Interpreter - integration - does Float64#to_s (simple) does Float64#to_s (simple) - does YAML::Serializable does YAML::Serializable - does Int32#to_s does Int32#to_s - does some Hash methods does some Hash methods - does JSON::Serializable does JSON::Serializable - does IO.pipe (checks that StaticArray is passed correctly to C calls) does IO.pipe (checks that StaticArray is passed correctly to C calls) - does YAML does YAML - does String#includes? does String#includes? - does CSV does CSV - does JSON does JSON - does Float64#to_s (complex) does Float64#to_s (complex) - does XML does XML - does caller does caller - does Range#to_a, Array#to_s does Range#to_a, Array#to_s -Normalize: case - normalizes select with else normalizes select with else - normalizes select with assign normalizes select with assign - normalizes select with assign and bang method normalizes select with assign and bang method - normalizes select with call normalizes select with call - normalizes select with assign and question method normalizes select with assign and question method -Semantic: multi assign - can pass splat variable at top-level to macros (#11596) can pass splat variable at top-level to macros (#11596) - strict_multi_assign - doesn't error if some type in union matches target count doesn't error if some type in union matches target count - errors if assigning union of tuples to fewer targets errors if assigning union of tuples to fewer targets - errors if assigning non-Indexable to splat (#11414) errors if assigning non-Indexable to splat (#11414) - errors if assigning non-Indexable (#11414) errors if assigning non-Indexable (#11414) - doesn't error if some type in union has no constant size doesn't error if some type in union has no constant size - errors if assigning tuple to more targets errors if assigning tuple to more targets - errors if assigning tuple to fewer targets errors if assigning tuple to fewer targets - without strict_multi_assign - doesn't error if assigning tuple to fewer targets doesn't error if assigning tuple to fewer targets - doesn't error if assigning non-Indexable (#11414) doesn't error if assigning non-Indexable (#11414) - errors if assigning non-Indexable to splat (#11414) errors if assigning non-Indexable to splat (#11414) -Normalize: hash literal - hoists complex element expressions, hash-like generic hoists complex element expressions, hash-like generic - normalizes non-empty with of normalizes non-empty with of - hoists complex element expressions, hash-like hoists complex element expressions, hash-like - normalizes non-empty without of normalizes non-empty without of - hoists complex element expressions hoists complex element expressions - normalizes empty with of normalizes empty with of -Code gen: generic class type - doesn't run generic instance var initializers in formal superclass's context (#4753) doesn't run generic instance var initializers in formal superclass's context (#4753) - doesn't crash on generic type restriction with no subtypes (#7583) doesn't crash on generic type restriction with no subtypes (#7583) - doesn't use virtual + in type arguments (#2839) doesn't use virtual + in type arguments (#2839) - inherited instance var initialize from generic to concrete (#2128) inherited instance var initialize from generic to concrete (#2128) - doesn't override guessed instance var in generic type if already declared in superclass (#9431) doesn't override guessed instance var in generic type if already declared in superclass (#9431) - runs generic instance var initializers in superclass's metaclass context (2) (#6482) runs generic instance var initializers in superclass's metaclass context (2) (#6482) - doesn't use virtual + in type arguments for Tuple (#2839) doesn't use virtual + in type arguments for Tuple (#2839) - codegens virtual generic metaclass macro method call codegens virtual generic metaclass macro method call - uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) uses big integer as generic type argument (#2353) - doesn't consider abstract types for including types (#7200) doesn't consider abstract types for including types (#7200) - codegens inherited generic class instance var codegens inherited generic class instance var - runs generic instance var initializers in superclass's metaclass context (#4753) runs generic instance var initializers in superclass's metaclass context (#4753) - invokes super in generic class (#2354) invokes super in generic class (#2354) - instantiates generic class with default argument in initialize (#394) instantiates generic class with default argument in initialize (#394) - doesn't use virtual + in type arguments for NamedTuple (#2839) doesn't use virtual + in type arguments for NamedTuple (#2839) - allows initializing instance variable (#665) allows initializing instance variable (#665) - codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 codegens compile-time interpreted generic int128 - doesn't consider abstract generic instantiation when restricting type (#5190) doesn't consider abstract generic instantiation when restricting type (#5190) - recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) recomputes two calls that look the same due to generic type being instantiated (#7728) - declares instance var with virtual T (#1675) declares instance var with virtual T (#1675) - codegens static array size after instantiating codegens static array size after instantiating - inherited instance var initialize from generic to generic to concrete (#2128) inherited instance var initialize from generic to generic to concrete (#2128) - doesn't crash on generic type restriction with initially no subtypes (#8411) doesn't crash on generic type restriction with initially no subtypes (#8411) - allows initializing instance variable in inherited generic type allows initializing instance variable in inherited generic type -Crystal::Doc::Method - args_to_s - shows underscore restriction shows underscore restriction - shows splat args shows splat args - shows block args shows block args - shows simple args shows simple args - shows default value of arg with highlighting shows default value of arg with highlighting - shows block args with underscore shows block args with underscore - shows double splat args shows double splat args - shows return type restriction shows return type restriction - shows block args if a def has `yield` shows block args if a def has `yield` - shows external name of arg shows external name of arg - shows external name of arg with quotes and escaping shows external name of arg with quotes and escaping - shows args and return type restriction shows args and return type restriction - shows typeof restriction of arg with highlighting shows typeof restriction of arg with highlighting - doc - inherits doc from ancestor (no extra comment) inherits doc from ancestor (no extra comment) - inherits doc from ancestor (use :inherit:) inherits doc from ancestor (use :inherit:) - trailing comment is not a doc comment trailing comment is not a doc comment - inherits doc from previous def (no extra comment) inherits doc from previous def (no extra comment) - trailing comment is not part of a doc comment trailing comment is not part of a doc comment - inherits doc from ancestor (use :inherit: plus more content) inherits doc from ancestor (use :inherit: plus more content) - gets doc from underlying method gets doc from underlying method -Crystal::Repl::Interpreter - multidispatch - casts multidispatch argument to the def's arg type casts multidispatch argument to the def's arg type - does multidispatch with captured block (#12217) does multidispatch with captured block (#12217) - does dispatch on one argument with struct receiver, and modifies it does dispatch on one argument with struct receiver, and modifies it - does dispatch on receiver type and argument type, multiple times does dispatch on receiver type and argument type, multiple times - does dispatch on one argument does dispatch on one argument - does dispatch on receiver type and argument type does dispatch on receiver type and argument type - passes self as pointer when doing multidispatch (2) passes self as pointer when doing multidispatch (2) - doesn't compile block if it's not used (no yield) doesn't compile block if it's not used (no yield) - passes self as pointer when doing multidispatch passes self as pointer when doing multidispatch - does dispatch on one argument inside module with implicit self does dispatch on one argument inside module with implicit self - does multidispatch with mandatory named arguments does multidispatch with mandatory named arguments - does multidispatch on virtual metaclass type (1) does multidispatch on virtual metaclass type (1) - does dispatch on virtual type does dispatch on virtual type - does dispatch on receiver type does dispatch on receiver type - does dispatch on one argument with block does dispatch on one argument with block - downcasts self from union to struct (pass pointer to self) downcasts self from union to struct (pass pointer to self) - does dispatch on one argument inside module with explicit receiver does dispatch on one argument inside module with explicit receiver - does multidispatch on virtual metaclass type (2) does multidispatch on virtual metaclass type (2) - initialize multidispatch initialize multidispatch -Code gen: module - can use generic module as instance variable type can use generic module as instance variable type - expands modules to its including types (3) (#1916) expands modules to its including types (3) (#1916) - declares and includes generic module, in macros T is a tuple literal declares and includes generic module, in macros T is a tuple literal - expands modules to its including types (2) (#1916) expands modules to its including types (2) (#1916) - codegens pointer of module and pass value to method codegens pointer of module and pass value to method - can instantiate generic module can instantiate generic module - can use generic module as instance variable type (2) can use generic module as instance variable type (2) - codegens pointer of module with method codegens pointer of module with method - casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) casts to union of module that is included in other module (#3323) - codegens pointer of module with method with two including types with one struct (2) codegens pointer of module with method with two including types with one struct (2) - codegens dispatch of union with module (#3647) codegens dispatch of union with module (#3647) - casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) casts to union of generic module that is included in other module (#3323) - declares proc with module type and invoke it with two different types that return themselves declares proc with module type and invoke it with two different types that return themselves - expands modules to its including types (#1916) expands modules to its including types (#1916) - codegens pointer of module with method with two including types with one struct codegens pointer of module with method with two including types with one struct - codegens module with virtual type codegens module with virtual type - codegens proc of a module that was never included codegens proc of a module that was never included - codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block codegens pointer of module with block - codegens cast to module with class and struct to nilable module codegens cast to module with class and struct to nilable module - codegens proc of module when generic type includes it codegens proc of module when generic type includes it - invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) invokes method on yielded module that has no instances (#1079) - codegens pointer of module with method with two including types codegens pointer of module with method with two including types - codegens cast to module that includes bool codegens cast to module that includes bool - declares proc with module type declares proc with module type -Code gen: proc - call proc pointer with args call proc pointer with args - saves receiver value of proc pointer `->@ivar.foo` saves receiver value of proc pointer `->@ivar.foo` - codegens proc in instance var initialize (#3016) codegens proc in instance var initialize (#3016) - codegens nilable proc type dispatch (1) codegens nilable proc type dispatch (1) - can pass Proc(T) to Proc(Nil) in type restriction (#8964) can pass Proc(T) to Proc(Nil) in type restriction (#8964) - allows using proc arg name shadowing local variable allows using proc arg name shadowing local variable - closures var on ->var.call (#8584) closures var on ->var.call (#8584) - makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference makes sure that proc pointer is transformed after type inference - call simple proc literal with return call simple proc literal with return - codegens nilable proc type (1) codegens nilable proc type (1) - doesn't crash on #2196 doesn't crash on #2196 - codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) codegens proc to implicit self in constant (#647) - codegens proc with another var codegens proc with another var - allows proc type of enum type allows proc type of enum type - codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct codegens issue with missing byval in proc literal inside struct - allows invoking a function with a subtype when defined as block spec allows invoking a function with a subtype when defined as block spec - codegens captured block that returns tuple codegens captured block that returns tuple - passes block to another function (bug: mangling of both methods was the same) passes block to another function (bug: mangling of both methods was the same) - codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type codegens proc that accepts array of type - call proc literal with return type call proc literal with return type - binds function pointer to associated call binds function pointer to associated call - allows proc pointer where self is a class allows proc pointer where self is a class - saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` saves receiver value of proc pointer `->@@cvar.foo` - takes pointerof function pointer takes pointerof function pointer - can assign proc that returns anything to proc that returns nil, using union type (#3655) can assign proc that returns anything to proc that returns nil, using union type (#3655) - codegens proc that references struct (bug) codegens proc that references struct (bug) - saves receiver value of proc pointer `->var.foo` saves receiver value of proc pointer `->var.foo` - can assign proc that returns anything to proc that returns nil (#3655) can assign proc that returns anything to proc that returns nil (#3655) - automatically casts proc that returns something to proc that returns void automatically casts proc that returns something to proc that returns void - codegens proc of generic type codegens proc of generic type - assigns nil and proc to nilable proc type assigns nil and proc to nilable proc type - uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) uses alias of proc with virtual type (#1347) - doesn't crash when taking a proc pointer that multidispatches on the top-level (#3822) doesn't crash when taking a proc pointer that multidispatches on the top-level (#3822) - mangles strings in such a way they don't conflict with funs (#1006) mangles strings in such a way they don't conflict with funs (#1006) - codegens proc with union type that returns itself codegens proc with union type that returns itself - codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) codegens proc literal hard type inference (1) - accesses T in macros as a TupleLiteral accesses T in macros as a TupleLiteral - call simple proc literal call simple proc literal - allows redefining fun allows redefining fun - doesn't crash when taking a proc pointer that multidispatches on a module (#3822) doesn't crash when taking a proc pointer that multidispatches on a module (#3822) - doesn't crash when taking a proc pointer to a virtual type (#9823) doesn't crash when taking a proc pointer to a virtual type (#9823) - returns proc as function pointer inside top-level fun (#14691) returns proc as function pointer inside top-level fun (#14691) - builds proc type from fun builds proc type from fun - gets proc to lib fun (#504) gets proc to lib fun (#504) - call proc pointer call proc pointer - allows invoking proc literal with smaller type allows invoking proc literal with smaller type - calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer calls function pointer - calls proc pointer with union (passed by value) arg calls proc pointer with union (passed by value) arg - codegens proc that accepts a union and is called with a single type codegens proc that accepts a union and is called with a single type - returns ProcPointer inside top-level fun (#14691) returns ProcPointer inside top-level fun (#14691) - executes proc pointer on primitive executes proc pointer on primitive - passes proc as &->expr to method that yields passes proc as &->expr to method that yields - codegens proc that returns a virtual type codegens proc that returns a virtual type - allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically allows passing proc type to C automatically - does new on proc type does new on proc type - casts from function pointer to proc casts from function pointer to proc - builds nilable proc type from fun builds nilable proc type from fun - codegens nilable proc type dispatch (2) codegens nilable proc type dispatch (2) - allows proc type of enum type with base type allows proc type of enum type with base type - gets proc pointer using virtual type (#1337) gets proc pointer using virtual type (#1337) - call proc pointer of instance method call proc pointer of instance method - codegens nilable proc type (2) codegens nilable proc type (2) - raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) raises if returning closure from top-level fun (#14691) - call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises call proc pointer of instance method that raises - allows invoking a function with a subtype allows invoking a function with a subtype - call proc literal with arguments call proc literal with arguments -Semantic: concrete_types - VirtualType with concrete base VirtualType with concrete base - GenericModuleInstanceType GenericModuleInstanceType - ModuleType ModuleType - VirtualType with abstract base VirtualType with abstract base - UnionType of structs UnionType of structs - VirtualMetaclassType with abstract base VirtualMetaclassType with abstract base - VirtualMetaclassType with concrete base VirtualMetaclassType with concrete base + interprets read instance var interprets read instance var + does constructor does constructor + does object_id does object_id + calls implicit class self method calls implicit class self method + does allocate, set instance var and get instance var does allocate, set instance var and get instance var + calls explicit struct self method calls explicit struct self method +Crystal::FFI::CallInterface + .variadic + basic basic + zero varargs zero varargs + validates args size validates args size + .new + with args with args + make struct make struct + all primitive arg types all primitive arg types + simple call simple call + sum struct sum struct + array array +Semantic: struct + passes subtype check with generic module type on virtual type (2) (#10302) passes subtype check with generic module type on virtual type (2) (#10302) + doesn't make virtual for Struct doesn't make virtual for Struct + can't extend struct from non-abstract struct can't extend struct from non-abstract struct + can't extend class from struct can't extend class from struct + can cast to base abstract struct can cast to base abstract struct + passes subtype check with generic module type on virtual type passes subtype check with generic module type on virtual type + types struct declaration types struct declaration + unifies type to virtual type unifies type to virtual type + doesn't make virtual for Float doesn't make virtual for Float + allows struct to participate in virtual allows struct to participate in virtual + can't extend struct from class can't extend struct from class + doesn't error if method is not found in abstract type doesn't error if method is not found in abstract type + can't reopen as class can't reopen as class + doesn't make virtual for Int doesn't make virtual for Int + can't be nilable can't be nilable + passes subtype check with generic module type on virtual type (3) passes subtype check with generic module type on virtual type (3) + types generic struct declaration types generic struct declaration + errors if defining finalize for struct (#3840) errors if defining finalize for struct (#3840) + can't reopen as module can't reopen as module + doesn't make virtual for Value doesn't make virtual for Value +Crystal::Macro + def methods + executes receiver executes receiver + executes double_splat executes double_splat + executes name executes name + executes block_arg executes block_arg + executes splat_index executes splat_index + executes return_type executes return_type + executes abstract? executes abstract? + executes body executes body + executes free_vars executes free_vars + executes args executes args + executes visibility executes visibility + executes accepts_block? executes accepts_block? + classvar methods + executes name executes name + exception handler methods + executes ensure executes ensure + executes rescue name executes rescue name + executes else executes else + executes else (nop) executes else (nop) + executes body executes body + executes rescues executes rescues + executes ensure (nop) executes ensure (nop) + executes rescue body executes rescue body + executes rescue types executes rescue types + proc notation methods + gets single input gets single input + gets empty output gets empty output + executes resolve executes resolve + executes resolve? executes resolve? + gets single output gets single output + gets multiple inputs gets multiple inputs + Crystal::ArrayLiteral + executes reject executes reject + executes index out of bounds executes index out of bounds + executes map with constants executes map with constants + executes splat executes splat + executes unshift executes unshift + executes sort with ids and strings executes sort with ids and strings + executes any? (true) executes any? (true) + executes find (finds) executes find (finds) + executes includes? executes includes? + executes first executes first + executes size executes size + executes splat with splat executes splat with splat + #map_with_index + without the index argument + returns the resulting array returns the resulting array + without the element argument + returns the resulting array returns the resulting array + without either argument + returns the resulting array returns the resulting array + with both arguments + returns the resulting array returns the resulting array + executes [] with range executes [] with range + executes map with arg executes map with arg + executes [] with computed range executes [] with computed range + executes of executes of + creates an array literal with a var creates an array literal with a var + executes sort with numbers executes sort with numbers + executes type executes type + executes last executes last + #each #each + calls block exactly once for each element in #sort_by calls block exactly once for each element in #sort_by + executes of (nop) executes of (nop) + #- + with TupleLiteral argument + removes the elements in RHS from LHS into an ArrayLiteral removes the elements in RHS from LHS into an ArrayLiteral + with ArrayLiteral argument + removes the elements in RHS from LHS into an ArrayLiteral removes the elements in RHS from LHS into an ArrayLiteral + executes sort with strings executes sort with strings + executes splat with symbols and strings executes splat with symbols and strings + executes any? (false) executes any? (false) + executes uniq executes uniq + executes all? (false) executes all? (false) + executes sort with ids executes sort with ids + executes [] with incomplete range executes [] with incomplete range + executes [] with two numbers executes [] with two numbers + executes identify executes identify + executes index 1 executes index 1 + executes find (doesn't find) executes find (doesn't find) + executes []= executes []= + executes sort_by executes sort_by + executes push executes push + executes empty? executes empty? + #each_with_index + without the element argument + builds the correct array builds the correct array + with both arguments + builds the correct array builds the correct array + without either argument + builds the correct array builds the correct array + without the index argument + builds the correct array builds the correct array + executes all? (true) executes all? (true) + executes is_a? executes is_a? + executes join executes join + executes type (nop) executes type (nop) + executes select executes select + executes map executes map + executes join with strings executes join with strings + executes reduce with no initial value executes reduce with no initial value + executes reduce with initial value executes reduce with initial value + #+ + with TupleLiteral argument + concatenates the literals into an ArrayLiteral concatenates the literals into an ArrayLiteral + with ArrayLiteral argument + concatenates the literals into an ArrayLiteral concatenates the literals into an ArrayLiteral + executes index 0 executes index 0 + macro if methods + executes cond executes cond + executes else executes else + executes then executes then + if methods + executes cond executes cond + executes then executes then + executes else (nop) executes else (nop) + executes else executes else + symbol methods + executes symbol != symbol executes symbol != symbol + executes symbol == symbol executes symbol == symbol + forwards methods to string forwards methods to string + Crystal::TypeNode + executes instance_vars on symbol type executes instance_vars on symbol type + #abstract? + Crystal::NonGenericClassType + class + non-abstract non-abstract + abstract abstract + struct + non-abstract non-abstract + abstract abstract + Crystal::NonGenericModuleType Crystal::NonGenericModuleType + Crystal::GenericClassType + struct + non-abstract non-abstract + abstract abstract + class + non-abstract non-abstract + abstract abstract + Crystal::GenericModuleType Crystal::GenericModuleType + executes instance executes instance + public? + false false + true true + executes class_vars on symbol type executes class_vars on symbol type + executes class vars executes class vars + executes type_vars executes type_vars + executes resolve? executes resolve? + #module? + Crystal::GenericModuleType Crystal::GenericModuleType + Crystal::NonGenericModuleType Crystal::NonGenericModuleType + Crystal::GenericClassType + struct struct + class class + Crystal::NonGenericClassType + struct struct + class class + visibility + public public + private private + #id + does not include trailing + for virtual type does not include trailing + for virtual type + executes <= executes <= + executes == executes == + executes size of tuple metaclass executes size of tuple metaclass + executes instance_vars executes instance_vars + executes class_vars on metaclass executes class_vars on metaclass + executes != executes != + #includers + returns an array of types `self` is directly included in returns an array of types `self` is directly included in + #struct? + Crystal::NonGenericClassType + class class + struct struct + Crystal::GenericModuleType Crystal::GenericModuleType + Crystal::NonGenericModuleType Crystal::NonGenericModuleType + Crystal::GenericClassType + struct struct + class class + executes ancestors (with generic) executes ancestors (with generic) + executes resolve executes resolve + #class? + Crystal::GenericClassType + class class + struct struct + Crystal::NonGenericModuleType Crystal::NonGenericModuleType + Crystal::NonGenericClassType + struct struct + class class + Crystal::GenericModuleType Crystal::GenericModuleType + executes >= executes >= + #name + simple type + returns the name of the type returns the name of the type + generic instance + prints multiple arguments for splat type var prints multiple arguments for splat type var + prints empty splat type var prints empty splat type var + does not print extra commas for empty splat type var (1) does not print extra commas for empty splat type var (1) + does not print extra commas for empty splat type var (2) does not print extra commas for empty splat type var (2) + prints generic type arguments prints generic type arguments + does not print extra commas for empty splat type var (3) does not print extra commas for empty splat type var (3) + generic type + includes the generic_args of the instantiated type by default includes the generic_args of the instantiated type by default + includes the generic_args of the type by default includes the generic_args of the type by default + generic_args + true + includes the generic_args of the type includes the generic_args of the type + includes the generic_args of the instantiated type includes the generic_args of the instantiated type + false + does not include the generic_args of the instantiated type does not include the generic_args of the instantiated type + does not include the generic_args of the type does not include the generic_args of the type + with an invalid type argument + should raise the proper exception should raise the proper exception + namespaced type + should return the FQN of the type should return the FQN of the type + #warning + emits a warning at a specific node emits a warning at a specific node + #has_inner_pointers? + works on structs works on structs + works on references works on references + works on ReferenceStorage works on ReferenceStorage + works on primitive values works on primitive values + executes methods executes methods + executes < executes < + executes class vars (with inheritance) executes class vars (with inheritance) + executes class methods executes class methods + executes private? + false false + true true + == and != devirtualize generic type arguments (#10730) == and != devirtualize generic type arguments (#10730) + executes class executes class + #union? + true true + false false + executes superclass executes superclass + executes ancestors executes ancestors + executes union_types (non-union) executes union_types (non-union) + executes > executes > + executes size of tuple executes size of tuple + executes instance_vars on metaclass executes instance_vars on metaclass + #nilable? + true true + false false + executes union_types (union) executes union_types (union) + multi_assign methods + executes values executes values + executes targets executes targets + executes assign without output executes assign without output + require methods + executes path executes path + Crystal::EnumDef + executes body executes body + executes name executes name + executes base_type executes base_type + executes kind executes kind + Crystal::External + executes is_a? executes is_a? + regex methods + executes options executes options + executes source executes source + control expression methods + executes exp executes exp + executes exp (nop) executes exp (nop) + Crystal::NamedTupleLiteral + executes to_a executes to_a + executes [] with invalid key type executes [] with invalid key type + executes [] not found executes [] not found + executes has_key? executes has_key? + executes map executes map + executes double splat executes double splat + executes []= executes []= + executes empty? executes empty? + #each + without either argument + builds the correct array builds the correct array + without the value argument + builds the correct array builds the correct array + with both arguments + builds the correct array builds the correct array + without the key argument + builds the correct array builds the correct array + executes keys executes keys + executes double splat with arg executes double splat with arg + executes values executes values + creates a named tuple literal with a var creates a named tuple literal with a var + executes is_a? executes is_a? + executes size executes size + executes double splat executes double splat + executes [] executes [] + is_a methods + executes receiver executes receiver + executes arg executes arg + arg methods + executes internal_name executes internal_name + executes restriction executes restriction + executes name executes name + executes default_value executes default_value + Crystal::TupleLiteral + #- + with TupleLiteral argument + removes the elements in RHS from LHS into a TupleLiteral removes the elements in RHS from LHS into a TupleLiteral + with ArrayLiteral argument + removes the elements in RHS from LHS into a TupleLiteral removes the elements in RHS from LHS into a TupleLiteral + executes all? (true) executes all? (true) + executes unshift executes unshift + #map_with_index + without the element argument + returns the resulting tuple returns the resulting tuple + without the index argument + returns the resulting tuple returns the resulting tuple + without either argument + returns the resulting tuple returns the resulting tuple + with both arguments + returns the resulting tuple returns the resulting tuple + executes find (doesn't find) executes find (doesn't find) + executes uniq executes uniq + executes reject executes reject + executes [] out of bounds executes [] out of bounds + executes splat with symbols and strings executes splat with symbols and strings + executes [] with 0 executes [] with 0 + executes join executes join + executes map with constants executes map with constants + creates a tuple literal with a var creates a tuple literal with a var + executes map with arg executes map with arg + executes first executes first + executes push executes push + executes join with strings executes join with strings + executes sort with strings executes sort with strings + executes map executes map + executes [] with incomplete range executes [] with incomplete range + executes size executes size + executes sort with ids executes sort with ids + executes empty? executes empty? + executes splat with splat executes splat with splat + executes [] with computed range executes [] with computed range + executes any? (false) executes any? (false) + executes sort with ids and strings executes sort with ids and strings + executes is_a? executes is_a? + executes any? (true) executes any? (true) + executes sort with numbers executes sort with numbers + #each_with_index + without the element argument + builds the correct array builds the correct array + without the index argument + builds the correct array builds the correct array + with both arguments + builds the correct array builds the correct array + without either argument + builds the correct array builds the correct array + executes includes? executes includes? + executes select executes select + #+ + with ArrayLiteral argument + concatenates the literals into a TupleLiteral concatenates the literals into a TupleLiteral + with TupleLiteral argument + concatenates the literals into a TupleLiteral concatenates the literals into a TupleLiteral + executes find (finds) executes find (finds) + executes all? (false) executes all? (false) + executes [] with 1 executes [] with 1 + executes splat executes splat + executes [] with range executes [] with range + executes last executes last + executes splat with arg executes splat with arg + #each #each + string methods + executes camelcase with lower executes camelcase with lower + executes string starts_with? string (true) executes string starts_with? string (true) + executes titleize executes titleize + executes string ends_with? char (false) executes string ends_with? char (false) + executes split with argument executes split with argument + executes underscore executes underscore + executes string starts_with? char (false) executes string starts_with? char (false) + executes tr executes tr + executes to_i(base) executes to_i(base) + executes string < string executes string < string + executes string includes? string (true) executes string includes? string (true) + executes string includes? string (false) executes string includes? string (false) + executes string includes? char (false) executes string includes? char (false) + executes string starts_with? string (false) executes string starts_with? string (false) + executes split with char argument executes split with char argument + executes lines executes lines + executes downcase executes downcase + executes string > macroid executes string > macroid + executes string > string executes string > string + executes string + char executes string + char + executes string =~ (false) executes string =~ (false) + executes chars executes chars + executes string < macroid executes string < macroid + executes [] with inclusive range executes [] with inclusive range + executes string starts_with? char (true) executes string starts_with? char (true) + executes string ends_with? char (true) executes string ends_with? char (true) + executes string chomp executes string chomp + executes string == string executes string == string + executes [] with computed range executes [] with computed range + executes string =~ (true) executes string =~ (true) + executes capitalize executes capitalize + executes upcase executes upcase + executes empty executes empty + executes camelcase with invalid lower arg type executes camelcase with invalid lower arg type + executes camelcase executes camelcase + executes count executes count + executes string ends_with? string (false) executes string ends_with? string (false) + executes string + string executes string + string + executes string ends_with? string (true) executes string ends_with? string (true) + executes to_i executes to_i + executes string includes? char (true) executes string includes? char (true) + executes to_utf16 executes to_utf16 + executes strip executes strip + executes split without arguments executes split without arguments + executes size executes size + executes string != string executes string != string + executes gsub executes gsub + executes [] with exclusive range executes [] with exclusive range + executes [] with incomplete range executes [] with incomplete range + Crystal::ExternalVar + executes type executes type + executes real_name executes real_name + executes name executes name + flag? + has flag has flag + doesn't have flag doesn't have flag + env + doesn't have key doesn't have key + has key has key + #parse_type + metaclass metaclass + path path + generic generic + union - | union - | + raises on extra unparsed tokens before the type raises on extra unparsed tokens before the type + exposes syntax warnings exposes syntax warnings + raises on non StringLiteral arguments raises on non StringLiteral arguments + proc proc + union - Union union - Union + raises on extra unparsed tokens after the type raises on extra unparsed tokens after the type + raises on empty string raises on empty string + union - in generic union - in generic + assign methods + executes target executes target + executes value executes value + metaclass methods + executes resolve? executes resolve? + executes resolve executes resolve + executes instance executes instance + block methods + executes args executes args + executes splat_index executes splat_index + executes body executes body + or methods + executes right executes right + executes left executes left + annotation methods + executes [] with NumberLiteral executes [] with NumberLiteral + executes [] with SymbolLiteral executes [] with SymbolLiteral + executes [] with MacroId executes [] with MacroId + executes name executes name + executes [] with other ASTNode, but raises an error executes [] with other ASTNode, but raises an error + executes [] with StringLiteral executes [] with StringLiteral + nilable cast methods + executes to executes to + executes obj executes obj + Crystal::RangeLiteral + executes to_a executes to_a + executes excludes_end? executes excludes_end? + executes map executes map + #each #each + executes begin executes begin + executes end executes end + cast methods + executes obj executes obj + executes to executes to + Crystal::Select + executes whens executes whens + executes else executes else + Crystal::CStructOrUnionDef + executes kind executes kind + executes name executes name + executes body executes body + executes union? executes union? + Crystal::MacroLiteral + executes value executes value + proc literal methods + executes body executes body + executes args executes args + executes return_type executes return_type + expressions methods + executes expressions executes expressions + readinstancevar methods + executes name executes name + executes obj executes obj + uninitialized var methods + executes type executes type + executes var executes var + path methods + executes global? executes global? + executes resolve? executes resolve? + executes resolve executes resolve + executes types executes types + executes names executes names + executes global executes global + Crystal::AnnotationDef + executes body executes body + executes kind executes kind + executes name executes name + number methods + executes // executes // + executes + and preserves type executes + and preserves type + executes <= (false) executes <= (false) + executes * executes * + executes <=> (returns nil) executes <=> (returns nil) + executes & executes & + executes <=> executes <=> + executes > (false) executes > (false) + executes <= (true) executes <= (true) + executes | executes | + #to_number #to_number + executes < (true) executes < (true) + executes >= (true) executes >= (true) + executes >> executes >> + executes - executes - + executes >= (false) executes >= (false) + executes unary - executes unary - + executes < (false) executes < (false) + preserves integer size (#10713) preserves integer size (#10713) + executes unary + executes unary + + executes + executes + + executes math operations using U/Int128 executes math operations using U/Int128 + executes ** executes ** + executes + with float executes + with float + executes << executes << + executes ^ executes ^ + executes % executes % + executes > (true) executes > (true) + executes unary ~ executes unary ~ + executes kind executes kind + Crystal::Asm + executes inputs executes inputs + executes alignstack? executes alignstack? + executes outputs executes outputs + executes clobbers executes clobbers + executes intel? executes intel? + executes text executes text + executes can_throw? executes can_throw? + executes volatile? executes volatile? + splat methods + executes exp executes exp + visibility modifier methods + executes visibility executes visibility + executes exp executes exp + proc pointer methods + executes obj when present executes obj when present + executes args when not empty executes args when not empty + executes name executes name + executes args when empty executes args when empty + executes global? executes global? + executes obj when absent executes obj when absent + Crystal::FunDef + executes variadic? executes variadic? + executes return_type executes return_type + executes has_body? executes has_body? + executes real_name executes real_name + executes name executes name + executes body executes body + executes args executes args + Crystal::LibDef + executes kind executes kind + executes name executes name + executes body executes body + union methods + executes types executes types + executes resolve executes resolve + executes resolve? executes resolve? + Crystal::MacroExpression + executes output? executes output? + executes exp executes exp + generic methods + executes name executes name + executes resolve executes resolve + executes type_vars executes type_vars + executes named_args executes named_args + executes types executes types + executes resolve? executes resolve? + instancevar methods + executes name executes name + executes assign executes assign + Crystal::Alias + executes name executes name + executes type executes type + Crystal::ModuleDef + executes body executes body + executes type_vars executes type_vars + executes kind executes kind + executes splat_index executes splat_index + executes name executes name + macro id methods + forwards methods to string forwards methods to string + compares with symbol compares with symbol + compares with string compares with string + while methods + executes body executes body + executes cond executes cond + macro for methods + executes vars executes vars + executes exp executes exp + executes body executes body + Crystal::Extend + executes name executes name + Crystal::HashLiteral + executes double splat executes double splat + executes double splat with arg executes double splat with arg + executes [] not found executes [] not found + executes of_value (nop) executes of_value (nop) + executes keys executes keys + executes to_a executes to_a + executes of_key executes of_key + executes empty? executes empty? + executes []= executes []= + executes is_a? executes is_a? + creates a hash literal with a var creates a hash literal with a var + executes size executes size + executes of_value executes of_value + executes of_key (nop) executes of_key (nop) + executes [] executes [] + executes type executes type + executes type (nop) executes type (nop) + executes has_key? executes has_key? + #each + without either argument + builds the correct array builds the correct array + without the key argument + builds the correct array builds the correct array + without the value argument + builds the correct array builds the correct array + with both arguments + builds the correct array builds the correct array + executes map executes map + executes double splat executes double splat + executes values executes values + case methods + in + executes exhaustive? executes exhaustive? + executes whens executes whens + executes when exhaustive? executes when exhaustive? + when + executes exhaustive? executes exhaustive? + executes cond executes cond + executes when body executes when body + executes whens executes whens + executes else executes else + executes when conds executes when conds + executes when exhaustive? executes when exhaustive? + unary expression methods + executes is_a? executes is_a? + executes exp executes exp + char methods + executes ord executes ord + Crystal::TypeDef + executes type executes type + executes name executes name + macro methods + executes name executes name + executes body executes body + executes double_splat executes double_splat + executes splat_index executes splat_index + executes args executes args + executes block_arg executes block_arg + executes visibility executes visibility + type declaration methods + executes type executes type + executes value executes value + executes var executes var + executes var when instance var executes var when instance var + #warning + emits a top level warning emits a top level warning + printing + p! p! + p p + puts puts + pp pp + print print + pp! pp! + responds_to methods + executes name executes name + executes receiver executes receiver + Crystal::AsmOperand + executes exp executes exp + executes constraint executes constraint + global methods + executes name executes name + Crystal::ClassDef + executes splat_index executes splat_index + executes type_vars executes type_vars + executes name executes name + executes superclass executes superclass + executes body executes body + executes struct? executes struct? + executes kind executes kind + executes abstract? executes abstract? + offsetof methods + executes offset executes offset + executes type executes type + Crystal::Primitive + executes name executes name + node methods + executes != on numbers (false) executes != on numbers (false) + class_name + executes class_name executes class_name + executes class_name executes class_name + executes class_name executes class_name + executes class_name executes class_name + executes class_name executes class_name + executes class_name executes class_name + #is_a? + union argument, unimplemented types union argument, unimplemented types + union argument, duplicate type union argument, duplicate type + union argument, mergeable union argument, mergeable + union argument, contains NoReturn union argument, contains NoReturn + union argument, undefined types union argument, undefined types + union argument union argument + symbolize + expands macro with symbolize call on string expands macro with symbolize call on string + expands macro with symbolize call on symbol expands macro with symbolize call on symbol + expands macro with symbolize call on id expands macro with symbolize call on id + #nil? + NumberLiteral NumberLiteral + Nop Nop + NilLiteral NilLiteral + executes != on numbers (true) executes != on numbers (true) + executes == on numbers (false) executes == on numbers (false) + executes == on symbols (false) (#240) executes == on symbols (false) (#240) + executes == on symbols (true) (#240) executes == on symbols (true) (#240) + executes == on numbers (true) executes == on numbers (true) + id + expands macro with id call on global path expands macro with id call on global path + expands macro with id call on char expands macro with id call on char + expands macro with id call on string expands macro with id call on string + expands macro with id call on path expands macro with id call on path + expands macro with id call on symbol expands macro with id call on symbol + expands macro with id call on number expands macro with id call on number + expands macro with id call on call expands macro with id call on call + #doc_comment + returns an empty MacroId if there are no docs on the node (wants_doc = false) returns an empty MacroId if there are no docs on the node (wants_doc = false) + ensures each newline has a `#` prefix ensures each newline has a `#` prefix + returns the call's docs if present as a MacroId (wants_doc = true) returns the call's docs if present as a MacroId (wants_doc = true) + location + column number column number + end line_number end line_number + filename filename + line_number line_number + end column number end column number + stringify + expands macro with stringify call on number expands macro with stringify call on number + expands macro with stringify call on call expands macro with stringify call on call + expands macro with stringify call on symbol expands macro with stringify call on symbol + expands macro with stringify call on string expands macro with stringify call on string + #doc + returns an empty string if there are no docs on the node (wants_doc = false) returns an empty string if there are no docs on the node (wants_doc = false) + returns a multiline comment returns a multiline comment + returns the call's docs if present (wants_doc = true) returns the call's docs if present (wants_doc = true) + and methods + executes left executes left + executes right executes right + Crystal::TypeOf + executes args executes args + call methods + executes block arg (nop) executes block arg (nop) + executes receiver executes receiver + executes named args name executes named args name + executes global? executes global? + executes block executes block + executes args executes args + executes named args executes named args + executes block arg executes block arg + executes name executes name + executes named args value executes named args value + yield methods + executes expressions executes expressions + executes scope (nop) executes scope (nop) + executes scope executes scope + Crystal::Include + executes name executes name + compares versions compares versions + metavar methods + executes nothing executes nothing + executes name executes name + executes id executes id + executes is_a? executes is_a? + Crystal::MacroVar + executes expressions executes expressions + executes name executes name + instancevar methods + executes name executes name Normalize: and + normalizes and with is_a? on var normalizes and with is_a? on var + normalizes and with assignment normalizes and with assignment + normalizes and without variable normalizes and without variable normalizes and with ! on var normalizes and with ! on var normalizes and with variable on the left normalizes and with variable on the left - normalizes and without variable normalizes and without variable - normalizes and with assignment normalizes and with assignment - normalizes and with is_a? on exp normalizes and with is_a? on exp - normalizes and with is_a? on var normalizes and with is_a? on var normalizes and with ! on var.is_a?(...) normalizes and with ! on var.is_a?(...) -Visibility modifiers - errors if invoking protected method from non-subclass, generated with macro that generates a macro errors if invoking protected method from non-subclass, generated with macro that generates a macro - defines protected initialize (#7501) defines protected initialize (#7501) - allows invoking protected method from the same class allows invoking protected method from the same class - allows invoking private setter with self allows invoking private setter with self - allows calling protected method from nested generic class (2) allows calling protected method from nested generic class (2) - allows invoking protected method from virtual type allows invoking protected method from virtual type - allows invoking protected from instance to class allows invoking protected from instance to class - allows setting visibility modifier to macro that generates many methods (1) allows setting visibility modifier to macro that generates many methods (1) - allows invoking protected method between types in the same namespace when inheriting allows invoking protected method between types in the same namespace when inheriting - allows invoking private method from the same class allows invoking private method from the same class - allows invoking protected method between types in the same namespace allows invoking protected method between types in the same namespace - automatically makes initialize be protected automatically makes initialize be protected - allows setting visibility modifier to macro allows setting visibility modifier to macro - errors if invoking protected method from top-level errors if invoking protected method from top-level - gives correct error on unknown call (#2838) gives correct error on unknown call (#2838) - disallows invoking private method disallows invoking private method - allows invoking protected method from namespaced type to namespace allows invoking protected method from namespaced type to namespace - errors if applying visibility modifier to non-def or non-call errors if applying visibility modifier to non-def or non-call - errors if invoking protected method from non-subclass errors if invoking protected method from non-subclass - allows invoking protected method from namespace to namespaced type allows invoking protected method from namespace to namespaced type - allows calling protected method from nested generic class (1) allows calling protected method from nested generic class (1) - allows invoking protected method from subclass allows invoking protected method from subclass - allows invoking protected method from subclass (2) allows invoking protected method from subclass (2) - handles virtual types (#8561) handles virtual types (#8561) - allows setting visibility modifier to macro that generates many methods (2) allows setting visibility modifier to macro that generates many methods (2) -Code gen: closure - ensures it can raise from the closure check ensures it can raise from the closure check - codegens closured nested in block codegens closured nested in block - allows passing an external function along allows passing an external function along - codegens super nested closure codegens super nested closure - codegens closured nested in block with a call with a closure with same names codegens closured nested in block with a call with a closure with same names - captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) captures block and accesses local variable (#2050) - codegens closure with instance var codegens closure with instance var - doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) doesn't free closure memory (bug) - codegens super nested closure with nested closured variable codegens super nested closure with nested closured variable - codegens closure with instance var and var codegens closure with instance var and var - codegens closure inside initialize inside block with self codegens closure inside initialize inside block with self - codegens multiple nested blocks codegens multiple nested blocks - allows passing proc literal to def that captures block with & allows passing proc literal to def that captures block with & - codegens nested closure that mentions var in both contexts codegens nested closure that mentions var in both contexts - codegens simple closure in function codegens simple closure in function - codegens nested closure with block (1) codegens nested closure with block (1) - codegens nested closure codegens nested closure - codegens closure with nested context without new closured vars codegens closure with nested context without new closured vars - codegens closure with block codegens closure with block - closures struct self closures struct self - codegens closure with self and var codegens closure with self and var - codegens nested closure with nested closured variable codegens nested closure with nested closured variable - doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method doesn't form a closure if invoking class method - codegens simple closure in function with argument codegens simple closure in function with argument - unifies types of closured var unifies types of closured var - codegens closure with block that declares same var codegens closure with block that declares same var - codegens closure with nested context without new closured vars but with block arg codegens closure with nested context without new closured vars but with block arg - codegens simple closure in block codegens simple closure in block - doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self doesn't form a closure if invoking class method with self - codegen closure in instance method without self closured codegen closure in instance method without self closured - doesn't incorrectly consider local as closured (#4948) doesn't incorrectly consider local as closured (#4948) - codegens nested closure with block (2) codegens nested closure with block (2) - transforms block to proc literal transforms block to proc literal - allows giving less block args when transforming block to proc literal allows giving less block args when transforming block to proc literal - codegens closure with struct codegens closure with struct - codegens closure with nested context without new closured vars codegens closure with nested context without new closured vars - codegens simple closure at global scope codegens simple closure at global scope - codegens closure with self and arguments codegens closure with self and arguments - allows passing an external function along (2) allows passing an external function along (2) - codegens proc literal with struct codegens proc literal with struct - codegens closure with def that has an if codegens closure with def that has an if - codegens closured self in block (#3388) codegens closured self in block (#3388) - allows passing block as proc literal to new and to initialize allows passing block as proc literal to new and to initialize - transforms block to proc literal with free var transforms block to proc literal with free var - codegens closure with implicit self and var codegens closure with implicit self and var - codegens closure with instance var and block codegens closure with instance var and block - allows mixing yield and block.call allows mixing yield and block.call -Code gen: macro - can refer to union (1) can refer to union (1) - expands def macro with @type.name with virtual (2) expands def macro with @type.name with virtual (2) - determines if overrides (false) determines if overrides (false) - forwards line number forwards line number - expands def macro with instance var and method call (bug) expands def macro with instance var and method call (bug) - codegens macro with comment (bug) (#1396) codegens macro with comment (bug) (#1396) - gets enum members as constants gets enum members as constants - determines if variable has default value determines if variable has default value - expands @type.name in virtual metaclass (2) expands @type.name in virtual metaclass (2) - expands def macro with @type.instance_vars with virtual expands def macro with @type.instance_vars with virtual - determines if method exists (false) determines if method exists (false) - receives &block receives &block - executes all_subclasses executes all_subclasses - can refer to abstract (1) can refer to abstract (1) - determines if overrides, through another class (true) determines if overrides, through another class (true) - can refer to types can refer to types - replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) replaces %s inside string inside interpolation, with braces (#2178) - recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added recalculates method when virtual metaclass type is added - determines if overrides (true) determines if overrides (true) - expands inline macro if (false) expands inline macro if (false) - gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type gets default value of instance variable of generic type - can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal can use macro inside hash literal - can refer to @type can refer to @type - expands def macro with @type.name with virtual expands def macro with @type.name with virtual - can use constants can use constants - expands @type.name in virtual metaclass (1) expands @type.name in virtual metaclass (1) - retains original yield expression (#2923) retains original yield expression (#2923) - expands macro defined in class expands macro defined in class - expands def macro with @type.instance_vars expands def macro with @type.instance_vars - can iterate union types can iterate union types - resolves alias in macro resolves alias in macro - expands def macro with var expands def macro with var - gets enum members with @type.constants gets enum members with @type.constants - expands inline macro if (true) expands inline macro if (true) - determines if overrides, with macro method (false) determines if overrides, with macro method (false) - can access type variables of a module can access type variables of a module - expands macro defined in base class expands macro defined in base class - can access type variables of a generic type can access type variables of a generic type - finds macro from virtual type finds macro from virtual type - uses indexed macro variable uses indexed macro variable - expands macro def with return (#1040) expands macro def with return (#1040) - forwards dir location forwards dir location - types macro expansion bug (#1734) types macro expansion bug (#1734) - allows overriding macro definition when redefining base class allows overriding macro definition when redefining base class - replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) replaces %s inside string inside interpolation (#2178) - expands macro with default arg and splat (#784) expands macro with default arg and splat (#784) - determines if overrides, through module (true) determines if overrides, through module (true) - can access type variables of a tuple can access type variables of a tuple - keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro keeps heredoc contents with interpolation inside macro - gets methods gets methods - expands macro as class method and accesses @type expands macro as class method and accesses @type - executes with named arguments executes with named arguments - can refer to union (2) can refer to union (2) - stringifies type without virtual marker stringifies type without virtual marker - keeps line number with a block keeps line number with a block - executes subclasses executes subclasses - gets constant gets constant - codegens macro def with splat (#496) codegens macro def with splat (#496) - can access free variables can access free variables - can refer to abstract (2) can refer to abstract (2) - doesn't skip abstract classes when defining macro methods doesn't skip abstract classes when defining macro methods - uses indexed macro variable with many keys uses indexed macro variable with many keys - fixes empty types of macro expansions (#1379) fixes empty types of macro expansions (#1379) - expands macro that invokes another macro expands macro that invokes another macro - expands macro with escaped quotes (#895) expands macro with escaped quotes (#895) - doesn't reuse macro nodes (bug) doesn't reuse macro nodes (bug) - correctly recomputes call (bug) correctly recomputes call (bug) - uses tuple T in method with free vars uses tuple T in method with free vars - expands macro with arguments expands macro with arguments - declares constant in macro (#838) declares constant in macro (#838) - executes with named arguments for positional arg (2) executes with named arguments for positional arg (2) - responds correctly to has_constant? with @top_level responds correctly to has_constant? with @top_level - expands macro with default arg and splat (2) (#784) expands macro with default arg and splat (2) (#784) - expands inline macro for expands inline macro for - does block unpacking inside macro expression (#13707) does block unpacking inside macro expression (#13707) - copies base macro def to sub-subtype even after it was copied to a subtype (#448) copies base macro def to sub-subtype even after it was copied to a subtype (#448) - access to the program with @top_level access to the program with @top_level - expands def macro with @type.instance_vars with subclass expands def macro with @type.instance_vars with subclass - expands macro with default arg and splat (3) (#784) expands macro with default arg and splat (3) (#784) - determines if method exists (true) determines if method exists (true) - initializes class var in macro initializes class var in macro - doesn't override local variable when using macro variable (2) doesn't override local variable when using macro variable (2) - expands def macro with @type.name expands def macro with @type.name - finds macro in class finds macro in class - expands inline macro expands inline macro - expands @def in macro expands @def in macro - executes with named arguments for positional arg (1) executes with named arguments for positional arg (1) - gets default value of instance variable gets default value of instance variable - passes #826 passes #826 - devirtualizes @type devirtualizes @type - can access type variables can access type variables - can access type variables that are not types can access type variables that are not types - forwards file location forwards file location - runs macro with splat runs macro with splat - uses invocation context uses invocation context - keeps heredoc contents inside macro keeps heredoc contents inside macro - expands @def in inline macro expands @def in inline macro - allows macro with default arguments allows macro with default arguments - expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) expands macro with op assign inside assign (#5568) - gets default value of instance variable of inherited type that also includes module gets default value of instance variable of inherited type that also includes module - expands def macro expands def macro - implicitly marks method as macro def when using @type implicitly marks method as macro def when using @type - runs macro with arg and splat runs macro with arg and splat - transforms hooks (bug) transforms hooks (bug) - expands Path with resolve method expands Path with resolve method - doesn't override local variable when using macro variable doesn't override local variable when using macro variable - initializes instance var in macro initializes instance var in macro - executes with named arguments for positional arg (3) executes with named arguments for positional arg (3) - checks if macro expansion returns (#821) checks if macro expansion returns (#821) - expands macro that yields expands macro that yields - gets correct class name when there are classes in the middle gets correct class name when there are classes in the middle - keeps line number with no block keeps line number with no block - expands macro and resolves type correctly expands macro and resolves type correctly - expands macro as class method expands macro as class method - says that enum has Flags annotation says that enum has Flags annotation - says that enum doesn't have Flags annotation says that enum doesn't have Flags annotation - codegens macro def with default arg (similar to #496) codegens macro def with default arg (similar to #496) - can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal can use macro inside array literal - correctly resolves constant inside block in macro def correctly resolves constant inside block in macro def - surrounds {{yield}} with begin/end surrounds {{yield}} with begin/end - errors if dynamic constant assignment after macro expansion errors if dynamic constant assignment after macro expansion - doesn't replace %q() (#2178) doesn't replace %q() (#2178) - expands macro expands macro - accepts compile-time flags accepts compile-time flags - doesn't replace %s in string (#2178) doesn't replace %s in string (#2178) -Semantic: def overload - types a call with overload selecting the most restrictive types a call with overload selecting the most restrictive - doesn't match tuples of different sizes doesn't match tuples of different sizes - matches a generic module argument matches a generic module argument - treats single splats with same restriction as equivalent (#12579) treats single splats with same restriction as equivalent (#12579) - prefers more specific overload than one with free variables prefers more specific overload than one with free variables - says `no overload matches` instead of `can't instantiate abstract class` on wrong argument in new method says `no overload matches` instead of `can't instantiate abstract class` on wrong argument in new method - matches a generic module argument with free var matches a generic module argument with free var - gets free variable from union restriction without a union gets free variable from union restriction without a union - matches generic class instance type with another one matches generic class instance type with another one - gets free variable from union restriction (2) gets free variable from union restriction (2) - types a call with overload with yield after typing another call without yield types a call with overload with yield after typing another call without yield - includes splat symbol in error message includes splat symbol in error message - types a call with overload self other match types a call with overload self other match - types a call with overload self with inherited type types a call with overload self with inherited type - matches virtual type to union matches virtual type to union - matches a union argument with free var, more types (2) matches a union argument with free var, more types (2) - restrict virtual type with virtual type restrict virtual type with virtual type - matches tuples and uses free var matches tuples and uses free var - single type restriction wins over union single type restriction wins over union - overloads union against non-union (#2904) overloads union against non-union (#2904) - types a call with overload with yield the other way types a call with overload with yield the other way - accepts overload with nilable type restriction accepts overload with nilable type restriction - matches a union argument with free var, more types (1) matches a union argument with free var, more types (1) - types a call with overload self types a call with overload self - gives correct error message, looking up parent defs, when no overload matches gives correct error message, looking up parent defs, when no overload matches - overloads on metaclass (3) (#2916) overloads on metaclass (3) (#2916) - lookup matches in virtual type inside union lookup matches in virtual type inside union - matches a generic module argument with free var (2) matches a generic module argument with free var (2) - considers NamedTuple in a module's including types (#10380) considers NamedTuple in a module's including types (#10380) - dispatches with named arg dispatches with named arg - errors when binding free variable to different types (2) errors when binding free variable to different types (2) - treats single splats with same restriction as equivalent (2) (#12579) treats single splats with same restriction as equivalent (2) (#12579) - compare_strictness - positional parameters - positional parameter with restriction vs single splat positional parameter with restriction vs single splat - single splat vs single splat with restriction (#3134) single splat vs single splat with restriction (#3134) - positional parameter with restriction vs single splat with stricter restriction positional parameter with restriction vs single splat with stricter restriction - positional parameter with stricter restriction vs single splat with restriction positional parameter with stricter restriction vs single splat with restriction - positional parameter vs single splat with restriction positional parameter vs single splat with restriction - specificity specificity - single splat restriction vs single splat with stricter restriction single splat restriction vs single splat with stricter restriction - named parameters - specificity specificity - double splat vs double splat with restriction double splat vs double splat with restriction - named parameter with stricter restriction vs double splat with restriction named parameter with stricter restriction vs double splat with restriction - named parameter vs double splat with restriction named parameter vs double splat with restriction - named parameter with restriction vs double splat (#5328) named parameter with restriction vs double splat (#5328) - named parameter with restriction vs double splat with stricter restriction named parameter with restriction vs double splat with stricter restriction - double splat restriction vs double splat with stricter restriction double splat restriction vs double splat with stricter restriction - specificity conflicts, named vs named - (required > splat) vs (required > splat) (required > splat) vs (required > splat) - (required > optional) vs (required > optional) (required > optional) vs (required > optional) - (required > splat) vs (optional > splat) (required > splat) vs (optional > splat) - (required > optional) vs (optional > splat) (required > optional) vs (optional > splat) - (optional > splat) vs (optional > splat) (optional > splat) vs (optional > splat) - (required > optional) vs (required > splat) (required > optional) vs (required > splat) - subsumption has higher precedence over specificity - double splat vs (required positional > optional positional) double splat vs (required positional > optional positional) - named vs (optional positional > single splat) named vs (optional positional > single splat) - same named parameter, required > optional same named parameter, required > optional - named vs (required named > double splat) named vs (required named > double splat) - single splat vs (optional named > double splat) single splat vs (optional named > double splat) - same positional parameter, required > single splat same positional parameter, required > single splat - double splat vs (required positional > single splat) double splat vs (required positional > single splat) - same named parameter, required > double splat same named parameter, required > double splat - single splat vs (required named > double splat) single splat vs (required named > double splat) - double splat vs (optional positional > single splat) double splat vs (optional positional > single splat) - named vs (required positional > single splat) named vs (required positional > single splat) - positional vs (optional positional > single splat) positional vs (optional positional > single splat) - named vs (optional named > double splat) named vs (optional named > double splat) - single splat vs (required named > optional named) single splat vs (required named > optional named) - same positional parameter, optional > single splat same positional parameter, optional > single splat - positional vs (required named > double splat) positional vs (required named > double splat) - positional vs (required positional > single splat) positional vs (required positional > single splat) - positional vs (optional named > double splat) positional vs (optional named > double splat) - positional vs (required positional > optional positional) positional vs (required positional > optional positional) - same positional parameter, required > optional same positional parameter, required > optional - named vs (required positional > optional positional) named vs (required positional > optional positional) - named vs (required named > optional named) named vs (required named > optional named) - same named parameter, optional > double splat same named parameter, optional > double splat - positional vs (required named > optional named) positional vs (required named > optional named) - specificity conflicts, positional vs named - (optional > splat) vs (required > optional) (optional > splat) vs (required > optional) - (required > splat) vs (optional > splat) (required > splat) vs (optional > splat) - (required > splat) vs (required > splat) (required > splat) vs (required > splat) - (required > optional) vs (optional > splat) (required > optional) vs (optional > splat) - (required > splat) vs (required > optional) (required > splat) vs (required > optional) - (required > optional) vs (required > splat) (required > optional) vs (required > splat) - (optional > splat) vs (optional > splat) (optional > splat) vs (optional > splat) - (optional > splat) vs (required > splat) (optional > splat) vs (required > splat) - (required > optional) vs (required > optional) (required > optional) vs (required > optional) - subsumption conflicts - named vs named named vs named - positional vs single splat positional vs single splat - positional vs double splat positional vs double splat - positional vs positional positional vs positional - positional vs named positional vs named - named vs double splat named vs double splat - single splat vs double splat single splat vs double splat - single splat vs named single splat vs named - matches types with free variables matches types with free variables - gives better error message with consecutive arguments sizes gives better error message with consecutive arguments sizes - matches a union metaclass argument with free var (#8071) matches a union metaclass argument with free var (#8071) - reports no overload matches with correct method owner (#2083) reports no overload matches with correct method owner (#2083) - types a call with overload selecting the most restrictive 2 types a call with overload selecting the most restrictive 2 - uses long name when no overload matches and name is the same (#1030) uses long name when no overload matches and name is the same (#1030) - compare self type with others compare self type with others - types a call with overload self in included module other type types a call with overload self in included module other type - does not consider global paths as free variables (1) does not consider global paths as free variables (1) - uses method defined in base class if the restriction doesn't match uses method defined in base class if the restriction doesn't match - overloads with named argument (#4465) overloads with named argument (#4465) - overloads on metaclass (#2916) overloads on metaclass (#2916) - types a call with overload Object type first overload types a call with overload Object type first overload - doesn't match with wrong number of type arguments (#313) doesn't match with wrong number of type arguments (#313) - finds method after including module in generic module (#1201) finds method after including module in generic module (#1201) - matches a union argument with free var matches a union argument with free var - resets free vars after a partial match is rejected (#10270) resets free vars after a partial match is rejected (#10270) - types a call with overload with yield types a call with overload with yield - can call overload with aliased generic restriction can call overload with aliased generic restriction - errors if union restriction has multiple free vars errors if union restriction has multiple free vars - errors if no overload matches on union against named arg with external param name (#10516) errors if no overload matches on union against named arg with external param name (#10516) - types a call with overload type second overload types a call with overload type second overload - gets free variable from union restriction gets free variable from union restriction - restricts on generic type without type arg restricts on generic type without type arg - types a call with overload matches virtual 2 types a call with overload matches virtual 2 - matches tuples of different sizes matches tuples of different sizes - resets free vars after a partial match is rejected (2) (#10185) resets free vars after a partial match is rejected (2) (#10185) - matches on partial union matches on partial union - restrict matches to minimum necessary 1 restrict matches to minimum necessary 1 - overloads on metaclass (2) (#2916) overloads on metaclass (2) (#2916) - types a call with overload type first overload types a call with overload type first overload - does not consider global paths as free variables (2) does not consider global paths as free variables (2) - restricts on generic type with free type arg restricts on generic type with free type arg - doesn't crash on unknown metaclass doesn't crash on unknown metaclass - types a call with overload self in included module types a call with overload self in included module - errors if generic type doesn't match errors if generic type doesn't match - errors if no overload matches on union against named arg (#2640) errors if no overload matches on union against named arg (#2640) - dispatch call to def with restrictions dispatch call to def with restrictions - filter union type with virtual filter union type with virtual - matches tuple with underscore matches tuple with underscore - dispatch call to def with restrictions dispatch call to def with restrictions - types a call with overload matches virtual types a call with overload matches virtual - types a call with overload types a call with overload - restricts union to generic class restricts union to generic class - errors when binding free variable to different types errors when binding free variable to different types - types a call with overload matches virtual 3 types a call with overload matches virtual 3 - errors if union restriction has multiple free vars (2) errors if union restriction has multiple free vars (2) - can call overload with generic restriction can call overload with generic restriction + normalizes and with is_a? on exp normalizes and with is_a? on exp +Semantic: c union + types union getter via pointer types union getter via pointer + types Union#new types Union#new + types union setter via pointer types union setter via pointer + errors if using void in union field type errors if using void in union field type + types union getter types union getter + errors if using void via typedef in union field type errors if using void via typedef in union field type + types union setter types union setter + errors if setting closure errors if setting closure + errors on empty c union (#633) errors on empty c union (#633) + types c union types c union +Code gen: def with default value + resolves expanded call to current type, not to virtual type resolves expanded call to current type, not to virtual type + codegens def with one default value codegens def with one default value + considers first the one with more arguments considers first the one with more arguments + considers first the one with a restriction considers first the one with a restriction + doesn't mix types of instance vars with initialize and new doesn't mix types of instance vars with initialize and new + codegens def new with one default value codegens def new with one default value +Normalize: op assign + normalizes exp.value &&= normalizes exp.value &&= + normalizes exp[value] += normalizes exp[value] += + normalizes var -= normalizes var -= + normalizes exp[value] &&= normalizes exp[value] &&= + normalizes exp[value] ||= normalizes exp[value] ||= + normalizes var &*= normalizes var &*= + normalizes exp[0] += normalizes exp[0] += + normalizes var ||= normalizes var ||= + normalizes var &&= normalizes var &&= + normalizes @var.value += normalizes @var.value += + normalizes var &+= normalizes var &+= + normalizes var[0] += normalizes var[0] += + normalizes exp.value ||= normalizes exp.value ||= + normalizes var.value += normalizes var.value += + normalizes var *= normalizes var *= + normalizes exp.value += normalizes exp.value += + normalizes @var[0] += normalizes @var[0] += + normalizes @@var.value += normalizes @@var.value += + normalizes var += normalizes var += + normalizes @@var[0] += normalizes @@var[0] += + normalizes var &-= normalizes var &-= +Normalize: string interpolation + normalizes heredoc normalizes heredoc + normalizes string interpolation with multiple lines normalizes string interpolation with multiple lines + normalizes string interpolation normalizes string interpolation + replaces string constant replaces string constant + replaces string constant that results from macro expansion replaces string constant that results from macro expansion + replaces through multiple levels replaces through multiple levels +Crystal::Command::FormatCommand + checks files format checks files format + formats stdin (bug + show-backtrace) formats stdin (bug + show-backtrace) + formats stdin (syntax error) formats stdin (syntax error) + formats files (bug + show-stacktrace) formats files (bug + show-stacktrace) + checks files format (excludes + includes) checks files format (excludes + includes) + formats files (error) formats files (error) + formats stdin (formatted) formats stdin (formatted) + formats files formats files + checks files format (excludes) checks files format (excludes) + formats files (dir) formats files (dir) + checks files format (ok) checks files format (ok) + formats stdin (bug) formats stdin (bug) + formats stdin formats stdin + formats files (bug) formats files (bug) + formats stdin (invalid byte sequence error) formats stdin (invalid byte sequence error) Code gen: type declaration - codegens initialize instance var with var declaration codegens initialize instance var with var declaration + codegens initialize instance var of superclass codegens initialize instance var of superclass + declares and initializes var declares and initializes var declares and initializes declares and initializes codegens initialize instance var codegens initialize instance var - declares and initializes var declares and initializes var - codegens initialize instance var of superclass codegens initialize instance var of superclass -Code gen: no return - codegens if with no return and variable used afterwards codegens if with no return and variable used afterwards - codegens untyped typeof (#5105) codegens untyped typeof (#5105) - codegens Pointer(NoReturn).malloc codegens Pointer(NoReturn).malloc - codegen types exception handler as NoReturn if ensure is NoReturn codegen types exception handler as NoReturn if ensure is NoReturn - codegens call with no return because of falsey if (#3661) codegens call with no return because of falsey if (#3661) - codegens no return variable declaration (#1508) codegens no return variable declaration (#1508) - codegens no return instance variable declaration (#1508) codegens no return instance variable declaration (#1508) - codegens if with NoReturn on then and union on else codegens if with NoReturn on then and union on else -Code gen: regex literal spec - works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) -Semantic: uninitialized - errors if declares var and then assigns other type errors if declares var and then assigns other type - declares as uninitialized declares as uninitialized - errors if declaring generic type without type vars (with instance var) errors if declaring generic type without type vars (with instance var) - works with uninitialized NoReturn (#3314) works with uninitialized NoReturn (#3314) - can uninitialize variable outside initialize (#2828) can uninitialize variable outside initialize (#2828) - disallows declaring var of type Struct disallows declaring var of type Struct - disallows declaring var of type Value disallows declaring var of type Value - uses virtual type for uninitialized (#8216) uses virtual type for uninitialized (#8216) - disallows declaring var of type Float disallows declaring var of type Float - declares as uninitialized and reads it declares as uninitialized and reads it - declares an instance variable in initialize as uninitialized declares an instance variable in initialize as uninitialized - disallows declaring var of type Enum disallows declaring var of type Enum - disallows declaring var of type Object disallows declaring var of type Object - disallows declaring var of type Class disallows declaring var of type Class - can uninitialize variable outside initialize, generic (#2828) can uninitialize variable outside initialize, generic (#2828) - disallows declaring var of type Number disallows declaring var of type Number - can use uninitialized with class type (#2940) can use uninitialized with class type (#2940) - disallows declaring var of type Int disallows declaring var of type Int - errors if declaring variable multiple times with different types (#917) errors if declaring variable multiple times with different types (#917) - errors if declaring generic type without type vars (with class var) errors if declaring generic type without type vars (with class var) - disallows declaring var of type Reference disallows declaring var of type Reference - has type (#3641) has type (#3641) -Semantic: previous_def - errors if there's no previous def errors if there's no previous def - types previous def with explicit arguments types previous def with explicit arguments - types previous def with forwarded arguments, different internal names (#8895) types previous def with forwarded arguments, different internal names (#8895) - types previous def with named arguments, def has bare splat parameter (2) (#8895) types previous def with named arguments, def has bare splat parameter (2) (#8895) - types previous def with named arguments, def has double splat parameter (#8895) types previous def with named arguments, def has double splat parameter (#8895) - types previous def with named arguments, def has bare splat parameter (#8895) types previous def with named arguments, def has bare splat parameter (#8895) - types previous def with forwarded arguments, def has parameters types previous def with forwarded arguments, def has parameters - types previous def when inside fun types previous def when inside fun - says wrong number of arguments for previous_def (#1223) says wrong number of arguments for previous_def (#1223) - types previous def with restrictions types previous def with restrictions - types previous def types previous def - types previous def when inside fun and forwards args types previous def when inside fun and forwards args - types previous def in generic class types previous def in generic class - types previous def with forwarded arguments, def has bare splat parameter (#8895) types previous def with forwarded arguments, def has bare splat parameter (#8895) -Code gen: if - codegens if without an else with false codegens if without an else with false - doesn't generate truthy if branch if doesn't need value (bug) doesn't generate truthy if branch if doesn't need value (bug) - codegen if with union type and else without type codegen if with union type and else without type - codegens if with return in both branches codegens if with return in both branches - codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter codegens if with return in else preserves type filter - restricts with || always falsey restricts with || always falsey - codegen if inside if codegen if inside if - codegens if of nilable type in then codegens if of nilable type in then - doesn't crash with if !is_a? using var in then doesn't crash with if !is_a? using var in then - codegen if with union type and then without type codegen if with union type and then without type - codegens #3104 codegens #3104 - codegens if with virtual codegens if with virtual - codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises codegens if with nested if that raises - codegens bug #1729 codegens bug #1729 - codegens if with an else with true codegens if with an else with true - codegens if with an else with false codegens if with an else with false - codes if with two whiles codes if with two whiles - doesn't crash no NoReturn var (true left cond) (#1823) doesn't crash no NoReturn var (true left cond) (#1823) - codegens if value from then codegens if value from then - codegens if of nilable type in then 2 codegens if of nilable type in then 2 - codegens if without an else with true codegens if without an else with true - codegen if with nested if that returns codegen if with nested if that returns - codegens nested if with var (ssa bug) codegens nested if with var (ssa bug) - considers or truthy/falsey right considers or truthy/falsey right - codegens if inside def without an else with true codegens if inside def without an else with true - codegens if with int codegens if with int - codegens if with nil codegens if with nil - doesn't crash no NoReturn var (non-true left cond) (#1823) doesn't crash no NoReturn var (non-true left cond) (#1823) - codegens if with pointer 0x100000000 pointer codegens if with pointer 0x100000000 pointer - codegens if with return and no else codegens if with return and no else - codegens if of nilable type in else 3 codegens if of nilable type in else 3 - codegens if with union codegens if with union - codegens if of nilable type in else codegens if of nilable type in else - doesn't crash with if !var using var in else doesn't crash with if !var using var in else -Code gen: union type - sorts restrictions when there are unions sorts restrictions when there are unions - codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s - assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union - codegens union type when no obj and restrictions codegens union type when no obj and restrictions - codegens if with same nested union codegens if with same nested union - codegens union type when no obj codegens union type when no obj - codegens union type for instance var codegens union type for instance var - codegens union type when obj is union and no args codegens union type when obj is union and no args - assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 - codegens union type as return value codegens union type as return value - assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union - codegens union type when obj is not union but arg is codegens union type when obj is not union but arg is - codegens union type when obj union but arg is not codegens union type when obj union but arg is not - codegens union type when obj is union and arg is union codegens union type when obj is union and arg is union - respects union payload alignment when upcasting Bool (#14898) respects union payload alignment when upcasting Bool (#14898) - dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable - assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 - provides T as a tuple literal provides T as a tuple literal + codegens initialize instance var with var declaration codegens initialize instance var with var declaration +Codegen: double splat + double splats named argument into arguments (1) double splats named argument into arguments (1) + double splats named argument with positional arguments double splats named argument with positional arguments + matches double splat on method with named args and regular args matches double splat on method with named args and regular args + double splats twice double splats twice + double splats named argument with named args (1) double splats named argument with named args (1) + double splats named argument with named args (2) double splats named argument with named args (2) + matches double splat with regular splat matches double splat with regular splat + removes literal types in all matches (#6239) removes literal types in all matches (#6239) + double splats named argument into arguments (2) double splats named argument into arguments (2) + evaluates double splat argument just once (#2677) evaluates double splat argument just once (#2677) + matches double splat on method with named args matches double splat on method with named args +View#module_name + hyphen followed by non-ascii letter is replaced by its character hyphen followed by non-ascii letter is replaced by its character + underscore is ignored underscore is ignored + namespace is divided by hyphen namespace is divided by hyphen +Crystal::Repl::Interpreter + unions + returns union type returns union type + put and remove from union, together with is_a? (truthy case) put and remove from union, together with is_a? (truthy case) + put and remove from union in instance var put and remove from union in instance var + returns large union type (#15041) returns large union type (#15041) + converts from NilableType to NonGenericClassType converts from NilableType to NonGenericClassType + put and remove from union, together with is_a? (falsey case) put and remove from union, together with is_a? (falsey case) + discards is_a? discards is_a? + puts union inside union puts union inside union + put and remove from union in local var put and remove from union in local var +Semantic: static array + can match N type argument of static array (#1203) can match N type argument of static array (#1203) + doesn't match other number type argument of static array (#1203) doesn't match other number type argument of static array (#1203) + types static array new with size being a constant types static array new with size being a constant + doesn't crash on restriction (#584) doesn't crash on restriction (#584) + can match number type argument of static array (#1203) can match number type argument of static array (#1203) + types static array new with size being a computed constant types static array new with size being a computed constant + doesn't crash on offsetof (#8858) doesn't crash on offsetof (#8858) + allows instantiating static array instance var in initialize of generic type allows instantiating static array instance var in initialize of generic type + types static array new types static array new + types static array with type as size types static array with type as size + errors on negative static array size errors on negative static array size + doesn't crash on sizeof (#8858) doesn't crash on sizeof (#8858) + types static array with var declaration types static array with var declaration + errors if trying to instantiate static array with N not an integer errors if trying to instantiate static array with N not an integer + doesn't crash on instance_sizeof (#8858) doesn't crash on instance_sizeof (#8858) + types static array new with size being a nested constant inside type declaration (#5426) types static array new with size being a nested constant inside type declaration (#5426) + types static array new with size being a computed constant, and use N (bug) types static array new with size being a computed constant, and use N (bug) +Semantic: tuples + accept tuple in type restriction accept tuple in type restriction + errors if non-tuple is splatted inside tuple (2) errors if non-tuple is splatted inside tuple (2) + doesn't unify tuple metaclasses (#5384) doesn't unify tuple metaclasses (#5384) + matches tuple with splat (#2932) matches tuple with splat (#2932) + errors on recursive splat expansion (#218) errors on recursive splat expansion (#218) + matches tuple with splat (2) (#2932) matches tuple with splat (2) (#2932) + errors on tuple too big (#3816) errors on tuple too big (#3816) + errors if using two splat indices on restriction errors if using two splat indices on restriction + merges two tuple types of same size merges two tuple types of same size + #[](RangeLiteral) + types, begin-less types, begin-less + types, inbound begin, end-less types, inbound begin, end-less + types, out of bound begin, nilable types, out of bound begin, nilable + types, inbound begin types, inbound begin + gives error when begin index is out of range gives error when begin index is out of range + types, begin-less, end-less types, begin-less, end-less + types, metaclass index types, metaclass index + types, exclusive range types, exclusive range + types, inbound begin, nilable types, inbound begin, nilable + types tuple of three elements types tuple of three elements + #[](NumberLiteral) + types, metaclass index types, metaclass index + gives error when indexing out of range on empty tuple gives error when indexing out of range on empty tuple + gives error when indexing out of range gives error when indexing out of range + types, inbound index types, inbound index + types, inbound index, nilable types, inbound index, nilable + types, out of bound, nilable types, out of bound, nilable + gives error when using named args on Tuple gives error when using named args on Tuple + types tuple of one element and then two elements types tuple of one element and then two elements + #[](Path) + works for tuple indexer works for tuple indexer + works for named tuple indexer works for named tuple indexer + errors on recursive splat expansion (2) (#361) errors on recursive splat expansion (2) (#361) + doesn't trigger recursive splat expansion error (#7164) doesn't trigger recursive splat expansion error (#7164) + allows tuple covariance allows tuple covariance + errors if non-tuple is splatted inside tuple errors if non-tuple is splatted inside tuple + types T as a tuple of metaclasses types T as a tuple of metaclasses + can iterate T can iterate T + errors on named tuple too big errors on named tuple too big + doesn't crash on tuple in not executed block (#6718) doesn't crash on tuple in not executed block (#6718) + can call [] on T can call [] on T + accepts tuple covariance in array accepts tuple covariance in array + types tuple with splats inside types tuple with splats inside + errors on recursive splat expansion (1) (#361) errors on recursive splat expansion (1) (#361) + can name a tuple type can name a tuple type + types tuple of one element types tuple of one element + doesn't error if Tuple has no args doesn't error if Tuple has no args Code gen: nilable cast - does nilable cast (true) does nilable cast (true) - does upcast does upcast does nilable cast (always true) does nilable cast (always true) - types as? with wrong type (#2775) types as? with wrong type (#2775) - upcasts type to virtual (#3304) upcasts type to virtual (#3304) - does cast to nil (1) does cast to nil (1) + upcasts type to virtual (2) (#3304) upcasts type to virtual (2) (#3304) casts union type to nilable type (#9342) casts union type to nilable type (#9342) + does cast to nil (1) does cast to nil (1) does cast to nil (2) does cast to nil (2) + types as? with wrong type (#2775) types as? with wrong type (#2775) codegens with NoReturn codegens with NoReturn + casts with block var that changes type (#3341) casts with block var that changes type (#3341) does nilable cast (false) does nilable cast (false) + upcasts type to virtual (#3304) upcasts type to virtual (#3304) + does upcast does upcast + does nilable cast (true) does nilable cast (true) +Codegen: const + inlines simple const inlines simple const + define a constant in lib define a constant in lib + initializes simple const initializes simple const + uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup + codegens constant that is declared later because of virtual dispatch codegens constant that is declared later because of virtual dispatch + finds nearest constant first finds nearest constant first + codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct + initializes ARGC_UNSAFE initializes ARGC_UNSAFE + initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception + supports closured vars inside initializers (#10474) supports closured vars inside initializers (#10474) + allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) + inlines const with math inlines const with math + constants with expression constants with expression + codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name + finds global constant finds global constant + synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants + doesn't crash if constant is used, but class is never instantiated (#1106) doesn't crash if constant is used, but class is never instantiated (#1106) + codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const + inlines char const inlines char const + runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) + supports storing function returning nil supports storing function returning nil + inlines bool const inlines bool const + initializes simple const via another const initializes simple const via another const + works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if + uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module + inlines const referencing another const inlines const referencing another const + gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class + invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const + define a constant define a constant + support constant inside a def support constant inside a def + inlines enum value inlines enum value + support nested constant support nested constant + declaring var declaring var declaring var declaring var declaring var declaring var declaring var declaring var declaring var declaring var + gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant + uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) + declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order + gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant + allows constants with same name allows constants with same name +Crystal::Repl::Interpreter + is_a? + does is_a? from NilableType to NonGenericClassType (true) does is_a? from NilableType to NonGenericClassType (true) + does is_a? from NilableType to GenericClassInstanceType (false) does is_a? from NilableType to GenericClassInstanceType (false) + does is_a? from NilableType to GenericClassInstanceType (true) does is_a? from NilableType to GenericClassInstanceType (true) + does is_a? from VirtualType to NonGenericClassType (false) does is_a? from VirtualType to NonGenericClassType (false) + does is_a? from VirtualType to NonGenericClassType (true) does is_a? from VirtualType to NonGenericClassType (true) + does is_a? from NilableReferenceUnionType to NonGenericClassType (true) does is_a? from NilableReferenceUnionType to NonGenericClassType (true) + does is_a? from NilableReferenceUnionType to NonGenericClassType (false) does is_a? from NilableReferenceUnionType to NonGenericClassType (false) + does is_a? from NilableType to NonGenericClassType (false) does is_a? from NilableType to NonGenericClassType (false) + does is_a? from NilableProcType to non-Nil does is_a? from NilableProcType to non-Nil + does is_a? from NilableProcType to Nil does is_a? from NilableProcType to Nil +Code gen: cast + casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError + downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment + casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError + can cast from Void* to virtual type (#3014) can cast from Void* to virtual type (#3014) + casts to module casts to module casts to module casts to module casts to module casts to module casts to module casts to module casts to module casts to module + casts between union types, where union has a tuple type (#3377) casts between union types, where union has a tuple type (#3377) + codegens class method when type id is available but not a virtual type (#3490) codegens class method when type id is available but not a virtual type (#3490) + sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment + allows casting nilable type to Void* (1) allows casting nilable type to Void* (1) + casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError + doesn't corrupt stack when downcasting union to union with different alignment (#14285) doesn't corrupt stack when downcasting union to union with different alignment (#14285) + casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError + can cast to metaclass (#11121) can cast to metaclass (#11121) + allows casting nilable type to Void* (2) allows casting nilable type to Void* (2) + casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts with block var that changes type (#3341) casts with block var that changes type (#3341) + casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int + allows casting object to pointer and back allows casting object to pointer and back + allows casting nilable type to Void* (3) allows casting nilable type to Void* (3) + upcasts from non-generic to generic upcasts from non-generic to generic + casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) + casts to bigger union casts to bigger union + upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment + casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) + cast virtual metaclass type to nilable virtual instance type (#12628) cast virtual metaclass type to nilable virtual instance type (#12628) + casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil + allows casting nil to Void* allows casting nil to Void* + casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type upcasts type to virtual (2) (#3304) upcasts type to virtual (2) (#3304) -expand - expands macro expression inside def expands macro expression inside def - expands macro control {% if %} with indent expands macro control {% if %} with indent - expands macro expression {{ ... }} with cursor inside it expands macro expression {{ ... }} with cursor inside it - expands macro expression inside def of private enum expands macro expression inside def of private enum - expands macro expression inside private struct expands macro expression inside private struct - expands macro control {% for %} with indent expands macro control {% for %} with indent - expands macro expression inside def of private struct expands macro expression inside def of private struct - doesn't expand normal call doesn't expand normal call - doesn't expand macro expression with cursor out of end doesn't expand macro expression with cursor out of end - expands simple macro expands simple macro - expands macro expression inside private enum expands macro expression inside private enum - expands macro expression inside class expands macro expression inside class - doesn't expand macro expression doesn't expand macro expression - expands simple macro with cursor inside it expands simple macro with cursor inside it - expands macro expression inside def of module expands macro expression inside def of module - expands macros with 3 level expands macros with 3 level - expands macro expression inside C union expands macro expression inside C union - expands macro expression {% ... %} with cursor at end of it expands macro expression {% ... %} with cursor at end of it - expands macro expression inside enum expands macro expression inside enum - expands simple macro with cursor at end of it expands simple macro with cursor at end of it - expands macro expression inside def of private module expands macro expression inside def of private module - expands macro control {% if %} with cursor inside it expands macro control {% if %} with cursor inside it - expands macro control {% for %} expands macro control {% for %} - expands macro expression inside def of private module expands macro expression inside def of private module - expands macro control {% if %} with cursor at end of it expands macro control {% if %} with cursor at end of it - expands macro expression inside module expands macro expression inside module - expands macro expression inside C union of private lib expands macro expression inside C union of private lib - expands macro of module expands macro of module - expands macro control {% for %} with cursor inside it expands macro control {% for %} with cursor inside it - expands complex macro expands complex macro - expands macro expression inside private lib expands macro expression inside private lib - expands macro of module with cursor at module name expands macro of module with cursor at module name - expands macro expression inside def of nested module expands macro expression inside def of nested module - expands macro expression {{ ... }} with cursor end of it expands macro expression {{ ... }} with cursor end of it - expands macro expression inside private class expands macro expression inside private class - doesn't expand macro expression doesn't expand macro expression - expands macro control {% for %} with cursor at end of it expands macro control {% for %} with cursor at end of it - expands macro expression inside C struct of private lib expands macro expression inside C struct of private lib - expands macro expression inside lib expands macro expression inside lib - expands macro expression inside private def expands macro expression inside private def - expands macro expression inside fun expands macro expression inside fun - expands macro expression {% ... %} expands macro expression {% ... %} - expands macro expression inside private module expands macro expression inside private module - expands macro of module with cursor at dot expands macro of module with cursor at dot - expands macro expression inside struct expands macro expression inside struct - expands macro expression {{ ... }} expands macro expression {{ ... }} - expands macro with doc expands macro with doc - expands macros with 2 level expands macros with 2 level - expands macro control {% if %} expands macro control {% if %} - expands macro expression inside C struct expands macro expression inside C struct - expands macro of module inside module expands macro of module inside module - expands macro expression inside def of nested private module expands macro expression inside def of nested private module - expands macro expression inside def of private class expands macro expression inside def of private class -Crystal::Repl::Interpreter - exception handling - executes ensure when returning from a block executes ensure when returning from a block - captures exception in variable captures exception in variable - executes ensure when exception is raised in body executes ensure when exception is raised in body - does else does else - raises and rescues specific exception type raises and rescues specific exception type - does ensure for else does ensure for else - does ensure for else when else raises does ensure for else when else raises - executes ensure when breaking from a block executes ensure when breaking from a block - executes ensure when returning a big value from a block executes ensure when returning a big value from a block - does ensure with explicit return does ensure with explicit return - does ensure without rescue/raise does ensure without rescue/raise - executes ensure when exception is raised in rescue executes ensure when exception is raised in rescue - executes ensure when returning from a block (2) executes ensure when returning from a block (2) - does rescue when nothing is raised does rescue when nothing is raised - raises and rescues anything raises and rescues anything - raises and rescues anything, does ensure when an exception is rescued raises and rescues anything, does ensure when an exception is rescued -Semantic: private - doesn't find private thing defined through recursive macro (#8715) doesn't find private thing defined through recursive macro (#8715) - finds private type from inside namespace finds private type from inside namespace - doesn't find private class in another file doesn't find private class in another file - doesn't find private module from outside namespace doesn't find private module from outside namespace - doesn't find private class from outside namespace doesn't find private class from outside namespace - doesn't find private constant from outside namespace, long name (#8831) doesn't find private constant from outside namespace, long name (#8831) - doesn't define private alias with global type name doesn't define private alias with global type name - doesn't find private def defined in macro in another file (#7681) doesn't find private def defined in macro in another file (#7681) - doesn't find private macro in another file doesn't find private macro in another file - doesn't find private alias from outside namespace doesn't find private alias from outside namespace - doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) - find module private macro inside the module find module private macro inside the module - find module private macro inside a module, which is inherited by the module find module private macro inside a module, which is inherited by the module - doesn't find module private macro outside the module doesn't find module private macro outside the module - doesn't find private lib from outside namespace doesn't find private lib from outside namespace - can use types in private type can use types in private type - doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) - doesn't define private constant with global type name doesn't define private constant with global type name - doesn't define private class with global type name doesn't define private class with global type name - doesn't find private module defined through macro (#8715) doesn't find private module defined through macro (#8715) - doesn't find private enum from outside namespace, long name (#8831) doesn't find private enum from outside namespace, long name (#8831) - doesn't find private enum from outside namespace doesn't find private enum from outside namespace - doesn't find private macro defined through macro (#8715) doesn't find private macro defined through macro (#8715) - doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) - doesn't find private module from outside namespace, long name (#8831) doesn't find private module from outside namespace, long name (#8831) - doesn't define private enum with global type name doesn't define private enum with global type name - finds private def when invoking from inside macro (#2082) finds private def when invoking from inside macro (#2082) - doesn't find private constant from outside namespace doesn't find private constant from outside namespace - doesn't find private def in another file doesn't find private def in another file - doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) - types private def correctly types private def correctly - doesn't find private constant in another file (#7850) doesn't find private constant in another file (#7850) - finds private type in same file finds private type in same file - finds private macro in same file finds private macro in same file - can use class var initializer in private type can use class var initializer in private type - doesn't define private module with global type name doesn't define private module with global type name - doesn't find private alias from outside namespace, long name (#8831) doesn't find private alias from outside namespace, long name (#8831) - finds private class in macro expansion finds private class in macro expansion - finds private def in same file that invokes another def finds private def in same file that invokes another def - can use instance var initializer in private type can use instance var initializer in private type - doesn't find private lib from outside namespace, long name (#8831) doesn't find private lib from outside namespace, long name (#8831) - doesn't inherit visibility from class node in macro hook (#8794) doesn't inherit visibility from class node in macro hook (#8794) - doesn't find private alias in another file doesn't find private alias in another file - doesn't find private class defined through macro (#8715) doesn't find private class defined through macro (#8715) - doesn't find private class from outside namespace, long name (#8831) doesn't find private class from outside namespace, long name (#8831) - finds private type from inside namespace in subclass finds private type from inside namespace in subclass - finds private macro in same file, invoking from another macro (#1265) finds private macro in same file, invoking from another macro (#1265) - doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) - doesn't define incorrect type in top-level namespace (#13511) doesn't define incorrect type in top-level namespace (#13511) - doesn't define private lib with global type name doesn't define private lib with global type name - finds private def in same file finds private def in same file - gives private constant error in macro gives private constant error in macro -types to_s of - does for type contained in generic module does for type contained in generic module - array of simple types array of simple types - nilable value type nilable value type - non-instantiated array non-instantiated array - union types - should have parens - as arg type as arg type - as return type as return type - should not have extra parens - in pointers in pointers - in arrays in arrays - in tuples in tuples - union of simple types union of simple types - nilable type with more than two elements, Nil at the end nilable type with more than two elements, Nil at the end - named tuple named tuple - does for type contained in generic class does for type contained in generic class - nilable reference type nilable reference type -Code gen: case - codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call codegens case when cond is a call - does case when with metaclass does case when with metaclass - codegens case with class codegens case with class - codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else codegens case without whens but else - codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions codegens case with two conditions - codegens case when constant bug (#1028) codegens case when constant bug (#1028) - codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition codegens case with one condition - codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns codegens case that always returns - codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else codegens case with else - codegens value-less case codegens value-less case -Lexer string - lexes string with slash quote lexes string with slash quote - lexes string with unicode codepoint lexes string with unicode codepoint - raises when identifier doesn't start with a letter or number raises when identifier doesn't start with a letter or number - lexes string with newline lexes string with newline - lexes string with slash t lexes string with slash t - lexes heredoc with empty line lexes heredoc with empty line - assigns correct location after heredoc (#346) assigns correct location after heredoc (#346) - lexes simple string with %( lexes simple string with %( - lexes regex string with escaped space with /.../ lexes regex string with escaped space with /.../ - lexes regex string with escaped slash with /.../ lexes regex string with escaped slash with /.../ - lexes backtick string lexes backtick string - lexes string with unicode codepoint in curly multiple times lexes string with unicode codepoint in curly multiple times - says syntax error on "\"\\uD800\"" says syntax error on "\"\\uD800\"" - lexes simple string with nested %{ lexes simple string with nested %{ - lexes heredoc with \r\n lexes heredoc with \r\n - lexes simple string with nested %< lexes simple string with nested %< - says syntax error on "\"\\u{}\"" says syntax error on "\"\\u{}\"" - lexes regex string lexes regex string - says syntax error on "\"\\uFEDZ\"" says syntax error on "\"\\uFEDZ\"" - lexes slash with no-escape char lexes slash with no-escape char - lexes simple string lexes simple string - lexes regex string with special chars with %r(...) lexes regex string with special chars with %r(...) - lexes string with only newline lexes string with only newline - lexes string with numeral lexes string with numeral - lexes regex string with special chars with /.../ lexes regex string with special chars with /.../ - lexes regex string with escaped space with %r(...) lexes regex string with escaped space with %r(...) - lexes double numeral lexes double numeral - raises on unterminated heredoc raises on unterminated heredoc - says syntax error on "\"\\u{110000}\"" says syntax error on "\"\\u{110000}\"" - lexes string with literal newline lexes string with literal newline - lexes string with slash lexes string with slash - lexes interpolations in heredocs lexes interpolations in heredocs - raises on unexpected EOF while lexing heredoc raises on unexpected EOF while lexing heredoc - lexes simple string with %| lexes simple string with %| - lexes simple string with nested %[ lexes simple string with nested %[ - lexes string with backslash lexes string with backslash - says syntax error on "\"\\u{DFFF}\"" says syntax error on "\"\\u{DFFF}\"" - lexes heredoc with spaces before close tag lexes heredoc with spaces before close tag - says syntax error on "\"\\u{D800}\"" says syntax error on "\"\\u{D800}\"" - lexes heredoc lexes heredoc - lexes string with interpolation with double numeral lexes string with interpolation with double numeral - lexes string with interpolation lexes string with interpolation - lexes regex string with escaped slash with %r(...) lexes regex string with escaped slash with %r(...) - lexes string with unicode codepoint in curly lexes string with unicode codepoint in curly - lexes simple string with nested %( lexes simple string with nested %( - says syntax error on "\"\\uDFFF\"" says syntax error on "\"\\uDFFF\"" -Code gen: struct - does phi of struct does phi of struct - codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) codegens virtual struct metaclass (#2551) (4) - can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct can cast virtual struct to specific struct - passes a generic struct as a parameter makes a copy passes a generic struct as a parameter makes a copy - codegens virtual struct metaclass (#2551) (2) codegens virtual struct metaclass (#2551) (2) - uses nilable struct uses nilable struct - codegens virtual structs union (2) codegens virtual structs union (2) - mutates a virtual struct mutates a virtual struct - creates structs with instance var creates structs with instance var - casts virtual struct to base type, only one subclass (#2885) casts virtual struct to base type, only one subclass (#2885) - allows assigning to struct argument (bug) allows assigning to struct argument (bug) - declares const struct declares const struct declares const struct declares const struct declares const struct declares const struct declares const struct declares const struct declares const struct declares const struct - codegens virtual struct codegens virtual struct - returns self with block returns self with block - codegens virtual struct with pointer codegens virtual struct with pointer - creates structs creates structs - passes a struct as a parameter makes a copy passes a struct as a parameter makes a copy - can call new on abstract struct with single child (#7309) can call new on abstract struct with single child (#7309) - codegens virtual structs union (1) codegens virtual structs union (1) - assigning a struct makes a copy (1) assigning a struct makes a copy (1) - uses struct in if uses struct in if uses struct in if uses struct in if uses struct in if uses struct in if uses struct in if uses struct in if uses struct in if uses struct in if - codegens virtual struct metaclass (#2551) (3) codegens virtual struct metaclass (#2551) (3) - codegens struct assigned to underscore (#1842) codegens struct assigned to underscore (#1842) - creates struct in def creates struct in def - assigning a struct makes a copy (2) assigning a struct makes a copy (2) - returns struct as a copy returns struct as a copy - codegens virtual struct metaclass (#2551) (1) codegens virtual struct metaclass (#2551) (1) - returns self returns self -Semantic: recursive struct check - errors on recursive struct through recursive alias (#4454) (#4455) errors on recursive struct through recursive alias (#4454) (#4455) - detects recursive struct through module detects recursive struct through module - errors on private recursive type errors on private recursive type - detects recursive generic struct through module (#4720) detects recursive generic struct through module (#4720) - errors on recursive struct through named tuple errors on recursive struct through named tuple - errors on recursive generic struct inside module errors on recursive generic struct inside module - errors on recursive struct errors on recursive struct - errors on recursive abstract struct through module (#11384) errors on recursive abstract struct through module (#11384) - errors on recursive struct inside module errors on recursive struct inside module - errors on mutually recursive struct errors on mutually recursive struct - errors on recursive struct through tuple errors on recursive struct through tuple - detects recursive generic struct through generic module (#4720) detects recursive generic struct through generic module (#4720) - detects recursive struct through inheritance (#3071) detects recursive struct through inheritance (#3071) -Code gen: tuple - merges two tuple types of same size (2) merges two tuple types of same size (2) - codegens tuple [1..1]? codegens tuple [1..1]? - codegens tuple [-3..2]? codegens tuple [-3..2]? - codegens tuple [1] codegens tuple [1] - allows tuple covariance allows tuple covariance - provides T as a tuple literal provides T as a tuple literal - merges two tuple types of same size (1) merges two tuple types of same size (1) - codegens tuple [2]? codegens tuple [2]? - upcasts tuple inside compatible tuple upcasts tuple inside compatible tuple - codegens tuple [0..1]? codegens tuple [0..1]? - codegens tuple metaclass [0..1] codegens tuple metaclass [0..1] - passed tuple to def passed tuple to def - codegens splats inside tuples codegens splats inside tuples - codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) codegens tuple union (bug because union size was computed incorrectly) - codegens tuple metaclass [0] codegens tuple metaclass [0] - upcasts tuple inside union to union with compatible tuple upcasts tuple inside union to union with compatible tuple - codegens tuple metaclass [0..0] codegens tuple metaclass [0..0] - codegens tuple metaclass [2]? codegens tuple metaclass [2]? - codegens tuple [0] codegens tuple [0] - codegens tuple [2..2]? codegens tuple [2..2]? - codegens tuple [0..0]? codegens tuple [0..0]? - codegens tuple [1]? codegens tuple [1]? - codegens tuple [0]? codegens tuple [0]? - allows malloc pointer of tuple allows malloc pointer of tuple - assigns tuple to compatible tuple assigns tuple to compatible tuple - codegens tuple [1..0]? codegens tuple [1..0]? - codegens tuple [1..0] codegens tuple [1..0] - accesses T and creates instance from it accesses T and creates instance from it - codegens tuple [1] (2) codegens tuple [1] (2) - codegens union of tuple of float with tuple of tuple of float codegens union of tuple of float with tuple of tuple of float - downcasts union inside tuple to value (#3907) downcasts union inside tuple to value (#3907) - gets size at compile time gets size at compile time - downcasts union to mixed tuple type downcasts union to mixed tuple type - codegens tuple metaclass [1..0] codegens tuple metaclass [1..0] - codegens tuple [2..2] codegens tuple [2..2] - codegens tuple metaclass [3..2]? codegens tuple metaclass [3..2]? - codegens tuple class codegens tuple class - codegens tuple [1..1] codegens tuple [1..1] - downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types downcasts union to mixed union with mixed tuple types - codegens tuple [0..2]? codegens tuple [0..2]? - assigns tuple inside union to union with compatible tuple assigns tuple inside union to union with compatible tuple - passes empty tuple and empty named tuple to a method (#2852) passes empty tuple and empty named tuple to a method (#2852) - codegens tuple [0..1] codegens tuple [0..1] - codegens tuple [0..2] codegens tuple [0..2] - codegens tuple [3..2]? codegens tuple [3..2]? - codegens tuple metaclass [1] codegens tuple metaclass [1] - upcasts tuple union to compatible tuple upcasts tuple union to compatible tuple - codegens tuple [0..0] codegens tuple [0..0] - assigns tuple union to compatible tuple assigns tuple union to compatible tuple - assigns two same-size tuple types to a same var (#3132) assigns two same-size tuple types to a same var (#3132) -Normalize: expressions - normalizes expressions with begin/end normalizes expressions with begin/end - normalizes an expression normalizes an expression - normalizes an empty expression with begin/end normalizes an empty expression with begin/end -Semantic: type - can call methods of original type can call methods of original type - can call methods of parent type can call methods of parent type - errors if original type doesn't support instance variables errors if original type doesn't support instance variables - can access instance variables of original type can access instance variables of original type -Code gen: sizeof - returns correct sizeof for abstract struct (#4319) returns correct sizeof for abstract struct (#4319) - gets sizeof NoReturn gets sizeof NoReturn - gets sizeof union gets sizeof union - gets sizeof Nil (#7644) gets sizeof Nil (#7644) - can use sizeof in type argument (1) can use sizeof in type argument (1) - alignof - gets alignof struct gets alignof struct - gets alignof primitive types gets alignof primitive types - gets alignof union gets alignof union - gets alignof class gets alignof class - alignof mixed union is not less than alignof its variant types alignof mixed union is not less than alignof its variant types - can use sizeof in type argument (2) can use sizeof in type argument (2) - gets instance_sizeof class gets instance_sizeof class - can use sizeof of virtual type can use sizeof of virtual type - can use instance_sizeof in type argument can use instance_sizeof in type argument - gets instance_sizeof a generic type with type vars gets instance_sizeof a generic type with type vars - gets sizeof Void gets sizeof Void - gets sizeof struct gets sizeof struct - gets sizeof Bool (#8272) gets sizeof Bool (#8272) - doesn't precompute sizeof of abstract struct (#7741) doesn't precompute sizeof of abstract struct (#7741) - gets sizeof int gets sizeof int - can use instance_sizeof of virtual type can use instance_sizeof of virtual type - gets sizeof class gets sizeof class - instance_alignof - gets instance_alignof class gets instance_alignof class - gets instance_alignof a generic type with type vars gets instance_alignof a generic type with type vars - doesn't precompute sizeof of module (#7741) doesn't precompute sizeof of module (#7741) -Lexer comments - lexes without comments enabled lexes without comments enabled - lexes correct number of spaces lexes correct number of spaces - lexes with comments enabled (2) lexes with comments enabled (2) - lexes with comments enabled lexes with comments enabled -Crystal::Repl::Interpreter - magic constants - does line number does line number - constants - hoists constants hoists constants - interprets self inside constant inside class interprets self inside constant inside class - interprets constant literal interprets constant literal - returns nil in the assignment returns nil in the assignment - interprets complex constant interprets complex constant -Semantic: restrictions augmenter - augments generic uninstantiated type augments generic uninstantiated type - augments relative public type augments relative public type - augments Char | Int32 | String augments Char | Int32 | String - augments Nil augments Nil - augments Char | Int32 | String augments Char | Int32 | String - augments Int32 augments Int32 - augments Float32 augments Float32 - augments Bool augments Bool - augments Proc(Int32, Char) augments Proc(Int32, Char) - augments recursive alias type (#12134) augments recursive alias type (#12134) - augments Pointer(Void) augments Pointer(Void) - augments NamedTuple(a: Int32, b: Char) augments NamedTuple(a: Int32, b: Char) - augments relative private type augments relative private type - augments virtual type augments virtual type - doesn't augment if assigned inside while doesn't augment if assigned inside while - doesn't augment if the no_restrictions_augmenter flag is present doesn't augment if the no_restrictions_augmenter flag is present - augments NoReturn augments NoReturn - augments for Union(*T) (#12435) augments for Union(*T) (#12435) - augments Array(Int32).class augments Array(Int32).class - augments Symbol augments Symbol - augments Int32.class augments Int32.class - augments Tuple(Int32, Char) augments Tuple(Int32, Char) - augments virtual metaclass type augments virtual metaclass type - doesn't augment if assigned inside if doesn't augment if assigned inside if - augments String augments String - augments Char augments Char - augments Array(String) augments Array(String) - augments Enumerable(Int32).class augments Enumerable(Int32).class - doesn't augment if assigned inside block doesn't augment if assigned inside block - augments type splat augments type splat - doesn't crash on macro that yields and defines class (#12142) doesn't crash on macro that yields and defines class (#12142) - augments Proc(Int32, Nil) augments Proc(Int32, Nil) - augments typedef augments typedef - augments relative private type in same namespace augments relative private type in same namespace - augments for class var augments for class var - augments StaticArray(Int32, 8) augments StaticArray(Int32, 8) -Code gen: lib - passes int as another float type in literal passes int as another float type in literal - can use enum as fun argument can use enum as fun argument - uses static array in lib extern (#5688) uses static array in lib extern (#5688) - allows setting/getting external variable as function pointer allows setting/getting external variable as function pointer - passes nil to varargs (#1570) passes nil to varargs (#1570) - casts C fun to Crystal proc when accessing instance var (#2515) casts C fun to Crystal proc when accessing instance var (#2515) - allows passing type to LibC if it has a converter with to_unsafe allows passing type to LibC if it has a converter with to_unsafe - refers to lib type (#960) refers to lib type (#960) - codegens lib var set and get codegens lib var set and get - get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) - get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) - can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return - allows invoking out with underscore allows invoking out with underscore - call to void function call to void function - doesn't crash with nil and varargs (#4414) doesn't crash with nil and varargs (#4414) - allows passing type to LibC if it has a converter with to_unsafe (bug) allows passing type to LibC if it has a converter with to_unsafe (bug) - can use enum as fun return can use enum as fun return - doesn't crash when casting -1 to UInt32 (#3594) doesn't crash when casting -1 to UInt32 (#3594) -Codegen: until - codegens until codegens until -Semantic: splat - matches instantiated generic with splat in generic type matches instantiated generic with splat in generic type - matches with type var splat inside explicit Union, when non-splat vars fail matches with type var splat inside explicit Union, when non-splat vars fail - matches with type var and splat of itself inside explicit Union (2) matches with type var and splat of itself inside explicit Union (2) - gives correct error when forwarding splat (2) gives correct error when forwarding splat (2) - splats arg and splat against splat (1) (#1042) splats arg and splat against splat (1) (#1042) - matches with type var splat inside explicit Union (2) matches with type var splat inside explicit Union (2) - errors with too few non-splat type arguments (2) errors with too few non-splat type arguments (2) - matches with type var and splat of itself inside explicit Union (3) matches with type var and splat of itself inside explicit Union (3) - uses bare *, doesn't let more args uses bare *, doesn't let more args - method with default arguments and splat matches call with one arg (#2766) method with default arguments and splat matches call with one arg (#2766) - matches with type var splat inside explicit Union, when all splat elements match matches with type var splat inside explicit Union, when all splat elements match - doesn't match splat in generic type with unsplatted tuple (#10164) doesn't match splat in generic type with unsplatted tuple (#10164) - doesn't crash on non-match (#2521) doesn't crash on non-match (#2521) - calls super with implicit splat arg (#1001) calls super with implicit splat arg (#1001) - matches with type var and splat of itself inside explicit Union matches with type var and splat of itself inside explicit Union - works if matches splat with type restriction works if matches splat with type restriction - matches type splat with splat in generic type (2) matches type splat with splat in generic type (2) - uses splat restriction after non-splat arguments (#5037) uses splat restriction after non-splat arguments (#5037) - doesn't match free var type splats inside explicit Union doesn't match free var type splats inside explicit Union - errors if splatting non-tuple type in return values errors if splatting non-tuple type in return values - errors if doesn't match splat with type restriction because of zero arguments errors if doesn't match splat with type restriction because of zero arguments - uses splat restriction with concrete type uses splat restriction with concrete type - uses splat restriction uses splat restriction - method with splat and optional named argument matches zero args call (#2746) method with splat and optional named argument matches zero args call (#2746) - errors if splatting non-tuple type in call arguments errors if splatting non-tuple type in call arguments - overloads with type restriction and splat (6) overloads with type restriction and splat (6) - overloads with type restriction and splat (2) overloads with type restriction and splat (2) - errors with too few non-splat type arguments (1) errors with too few non-splat type arguments (1) - Crystal::Splat - without splat without splat - with splat with splat - uses splat restriction, matches empty uses splat restriction, matches empty - redefines method with splat (bug #248) redefines method with splat (bug #248) - overloads with type restriction and splat (1) overloads with type restriction and splat (1) - errors on zero args with named arg and splat errors on zero args with named arg and splat - overloads with splat against method with two arguments (#986) (2) overloads with splat against method with two arguments (#986) (2) - matches with tuple splat inside explicit Union matches with tuple splat inside explicit Union - matches with type var splat inside explicit Union, when one splat fails entirely matches with type var splat inside explicit Union, when one splat fails entirely - overloads with type restriction and splat (4) overloads with type restriction and splat (4) - matches partially instantiated generic with splat in generic type matches partially instantiated generic with splat in generic type - splats splats - accesses T when empty, via module accesses T when empty, via module - says missing argument because positional args don't match past splat says missing argument because positional args don't match past splat - matches with splat matches with splat - overloads with type restriction and splat (5) overloads with type restriction and splat (5) - forwards tuple with an extra argument forwards tuple with an extra argument - errors if doesn't match splat with type restriction errors if doesn't match splat with type restriction - errors with too many non-splat type arguments errors with too many non-splat type arguments - matches type splat with splat in generic type (1) matches type splat with splat in generic type (1) - overloads with type restriction and splat (3) overloads with type restriction and splat (3) - forwards tuple in return statement forwards tuple in return statement - matches with type var splat inside explicit Union matches with type var splat inside explicit Union - allows default value after splat index allows default value after splat index - errors if using two splat indices on restriction errors if using two splat indices on restriction - uses bare * uses bare * - overloads with splat against method with two arguments (#986) (1) overloads with splat against method with two arguments (#986) (1) - doesn't shift a call's location doesn't shift a call's location - splats arg and splat against splat (2) (#1042) splats arg and splat against splat (2) (#1042) - overloads with type restriction and splat (7) overloads with type restriction and splat (7) - says no overload matches on type restrictions past the splat arg says no overload matches on type restrictions past the splat arg - can splat after type filter left it as a tuple (#442) can splat after type filter left it as a tuple (#442) - errors if splatting union errors if splatting union - gives correct error when forwarding splat gives correct error when forwarding splat + upcasts type to virtual (#3304) upcasts type to virtual (#3304) + casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type + casts to base class making it virtual casts to base class making it virtual + casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer Semantic: proc - can match *T in block argument can match *T in block argument - allows passing union including module to proc allows passing union including module to proc - *doesn't* merge Proc that returns NoReturn with another one that returns something else (#9971) *doesn't* merge Proc that returns NoReturn with another one that returns something else (#9971) - disallows Struct in proc return types disallows Struct in proc return types - disallows Enum in procs disallows Enum in procs - allows passing proc type if it is typedef'd allows passing proc type if it is typedef'd - disallows Struct in proc notation parameter type disallows Struct in proc notation parameter type - allows metaclass in proc notation return type allows metaclass in proc notation return type - disallows Number in proc notation parameter type disallows Number in proc notation parameter type - disallows Int in procs disallows Int in procs - says wrong return type in new on proc type says wrong return type in new on proc type - allows passing NoReturn type for any return type (1) allows passing NoReturn type for any return type (1) - types proc call types proc call - disallows Pointer in proc notation return type disallows Pointer in proc notation return type - disallows Value in captured block disallows Value in captured block - disallows StaticArray in procs disallows StaticArray in procs - unpacks tuple but doesn't override local variables, when using new (#9813) unpacks tuple but doesn't override local variables, when using new (#9813) - types proc pointer types proc pointer - disallows Object in proc notation return type disallows Object in proc notation return type - allows using Proc as restriction (1) allows using Proc as restriction (1) - types proc pointer to instance method types proc pointer to instance method - disallows Float in proc notation return type disallows Float in proc notation return type - disallows Class in proc notation return type disallows Class in proc notation return type - doesn't let passing an non-covariant generic argument doesn't let passing an non-covariant generic argument - binds proc literal to arguments and body binds proc literal to arguments and body - accesses T and R accesses T and R - allows passing function to LibC without specifying types, using a class method allows passing function to LibC without specifying types, using a class method - errors if inferred return type doesn't match return type restriction (2) errors if inferred return type doesn't match return type restriction (2) - types Proc(*T, Void) as Proc(*T, Nil) types Proc(*T, Void) as Proc(*T, Nil) - disallows Object in proc notation parameter type disallows Object in proc notation parameter type - can assign proc that returns anything to proc that returns nil, with instance var (#3655) can assign proc that returns anything to proc that returns nil, with instance var (#3655) - disallows Reference in proc return types disallows Reference in proc return types - types nil or proc type types nil or proc type - allows using proc arg name shadowing local variable allows using proc arg name shadowing local variable - disallows Class in proc return types disallows Class in proc return types - disallows Class in captured block disallows Class in captured block - allows passing virtual type including module to proc allows passing virtual type including module to proc - finds method of object finds method of object - doesn't capture closured var if using typeof doesn't capture closured var if using typeof - allows casting a proc type to one with void argument allows casting a proc type to one with void argument - uses array argument of proc arg (3) uses array argument of proc arg (3) - allows passing nil as proc callback if it is a lib alias allows passing nil as proc callback if it is a lib alias - disallows Value in procs disallows Value in procs - disallows Tuple in procs disallows Tuple in procs - disallows Value in proc pointer disallows Value in proc pointer - errors when using macro as proc value (inside method) (#7465) errors when using macro as proc value (inside method) (#7465) - disallows StaticArray in proc notation parameter type disallows StaticArray in proc notation parameter type - can use @@cvar as pointer syntax receiver (#9239) can use @@cvar as pointer syntax receiver (#9239) - disallows Object in procs disallows Object in procs - disallows Object in proc pointer disallows Object in proc pointer - errors if inferred return type doesn't match return type restriction (1) errors if inferred return type doesn't match return type restriction (1) - disallows Pointer in proc pointer disallows Pointer in proc pointer - disallows Object in captured block disallows Object in captured block - types int -> int proc literal types int -> int proc literal - errors when using macro as proc value (top-level with obj) (#7465) errors when using macro as proc value (top-level with obj) (#7465) - disallows Class in procs disallows Class in procs - disallows casting a proc type to one accepting same size argument but different input disallows casting a proc type to one accepting same size argument but different input - types int -> int proc call types int -> int proc call - passes proc pointer as block with arguments passes proc pointer as block with arguments - disallows Struct in procs disallows Struct in procs - virtualizes proc type with -> (#8730) virtualizes proc type with -> (#8730) + types proc call with return type types proc call with return type + types proc literal with a type that was never instantiated types proc literal with a type that was never instantiated + disallows Pointer in proc return types disallows Pointer in proc return types + can pass Proc(X, T) to Proc(X, Nil) in type restriction (#8964) can pass Proc(X, T) to Proc(X, Nil) in type restriction (#8964) + disallows Reference in proc notation return type disallows Reference in proc notation return type passes proc pointer as block passes proc pointer as block - disallows Proc in proc pointer disallows Proc in proc pointer - allows new on proc type allows new on proc type - sets proc type as void if explicitly told so, when using new sets proc type as void if explicitly told so, when using new - doesn't crash on constant to proc pointer doesn't crash on constant to proc pointer - allows using Proc as restriction (3) allows using Proc as restriction (3) - can assign proc that returns anything to proc that returns nil, with class var (#3655) can assign proc that returns anything to proc that returns nil, with class var (#3655) + can assign proc that returns anything to proc that returns nil, with local var (#3655) can assign proc that returns anything to proc that returns nil, with local var (#3655) disallows StaticArray in captured block disallows StaticArray in captured block - has proc literal as restriction and works has proc literal as restriction and works - doesn't cause upcast bug (#8428) doesn't cause upcast bug (#8428) - allows metaclass in proc notation parameter type allows metaclass in proc notation parameter type - disallows Number in captured block disallows Number in captured block - disallows Pointer in captured block disallows Pointer in captured block - types proc pointer with types types proc pointer with types - disallows Number in procs disallows Number in procs - gives correct error message when proc return type is incorrect (#219) gives correct error message when proc return type is incorrect (#219) - can pass proc that returns T as Void with named args (#7523) can pass proc that returns T as Void with named args (#7523) - types proc type spec types proc type spec + disallows Tuple in proc pointer disallows Tuple in proc pointer + disallows Tuple in proc notation parameter type disallows Tuple in proc notation parameter type has proc literal as restriction and errors if input is different has proc literal as restriction and errors if input is different - disallows Enum in proc return types disallows Enum in proc return types allows implicit cast of proc to return void in generic restriction allows implicit cast of proc to return void in generic restriction - *doesn't* merge Proc that returns Nil with another one that returns something else (#3655) (this was reverted) *doesn't* merge Proc that returns Nil with another one that returns something else (#3655) (this was reverted) - disallows Proc in procs disallows Proc in procs - disallows Reference in proc notation parameter type disallows Reference in proc notation parameter type - can use @ivar as pointer syntax receiver (#9239) can use @ivar as pointer syntax receiver (#9239) - merges return type merges return type - forwards block and computes correct type (bug) forwards block and computes correct type (bug) - disallows Int in proc notation parameter type disallows Int in proc notation parameter type - allows passing function to LibC without specifying types, using a global method allows passing function to LibC without specifying types, using a global method - accesses T inside variadic generic accesses T inside variadic generic - disallows Class in proc pointer disallows Class in proc pointer - allows metaclass in captured block allows metaclass in captured block - disallows Struct in captured block disallows Struct in captured block - disallows Value in proc notation parameter type disallows Value in proc notation parameter type - allows implicit cast of proc to return void in LibC function allows implicit cast of proc to return void in LibC function - disallows Pointer in procs disallows Pointer in procs - uses array argument of proc arg (4) uses array argument of proc arg (4) - disallows Tuple in proc notation return type disallows Tuple in proc notation return type - disallows Reference in proc notation return type disallows Reference in proc notation return type - disallows Proc in proc notation return type disallows Proc in proc notation return type - allows metaclass in proc pointer allows metaclass in proc pointer - types int proc literal types int proc literal - allows using Proc as restriction (2) allows using Proc as restriction (2) - disallows Struct in proc notation return type disallows Struct in proc notation return type - errors when using macro as proc value (top-level) (#7465) errors when using macro as proc value (top-level) (#7465) - errors if missing argument type in proc literal errors if missing argument type in proc literal - disallows Float in proc return types disallows Float in proc return types - has proc literal as restriction and works when output not specified has proc literal as restriction and works when output not specified - disallows Tuple in proc notation parameter type disallows Tuple in proc notation parameter type - accesses T inside variadic generic, in proc notation accesses T inside variadic generic, in proc notation - disallows Enum in proc notation parameter type disallows Enum in proc notation parameter type + disallows Object in procs disallows Object in procs + disallows Object in proc return types disallows Object in proc return types + doesn't cause upcast bug (#8428) doesn't cause upcast bug (#8428) + disallows StaticArray in procs disallows StaticArray in procs + disallows casting a proc type to one accepting same size argument but different input disallows casting a proc type to one accepting same size argument but different input + disallows Object in proc pointer disallows Object in proc pointer + disallows Struct in proc return types disallows Struct in proc return types + disallows Object in proc notation return type disallows Object in proc notation return type + types proc pointer with a type that was never instantiated types proc pointer with a type that was never instantiated + types proc literal with return type (2) types proc literal with return type (2) + disallows Class in procs disallows Class in procs types proc literal with return type (1) types proc literal with return type (1) - can assign proc that returns anything to proc that returns nil, with local var (#3655) can assign proc that returns anything to proc that returns nil, with local var (#3655) - disallows Float in procs disallows Float in procs - disallows casting a proc type to one accepting more arguments disallows casting a proc type to one accepting more arguments - allows metaclass in procs allows metaclass in procs disallows Value in proc notation return type disallows Value in proc notation return type - disallows Float in captured block disallows Float in captured block + doesn't let passing an non-covariant generic argument doesn't let passing an non-covariant generic argument + disallows Tuple in proc notation return type disallows Tuple in proc notation return type + forwards block and computes correct type (bug) forwards block and computes correct type (bug) + disallows Proc in proc notation return type disallows Proc in proc notation return type + unpacks tuple but doesn't override local variables, when using new (#9813) unpacks tuple but doesn't override local variables, when using new (#9813) + allows new on proc type with less block params allows new on proc type with less block params types empty proc literal types empty proc literal + has proc literal as restriction and works when output not specified has proc literal as restriction and works when output not specified + errors if missing argument type in proc literal errors if missing argument type in proc literal + allows implicit cast of proc to return void in LibC function allows implicit cast of proc to return void in LibC function + can pass proc that returns T as Void with named args (#7523) can pass proc that returns T as Void with named args (#7523) + disallows Int in captured block disallows Int in captured block + disallows Number in proc pointer disallows Number in proc pointer + allows casting a proc type to one with void argument allows casting a proc type to one with void argument + declares an instance variable with splat in proc notation declares an instance variable with splat in proc notation + disallows Reference in proc pointer disallows Reference in proc pointer + disallows Tuple in proc return types disallows Tuple in proc return types + types proc literal hard type inference (1) types proc literal hard type inference (1) + merges return type merges return type + disallows Int in proc notation parameter type disallows Int in proc notation parameter type + disallows Float in proc notation parameter type disallows Float in proc notation parameter type + allows passing proc type if it is a lib alias allows passing proc type if it is a lib alias + disallows Reference in captured block disallows Reference in captured block + types int -> int proc literal types int -> int proc literal + disallows Tuple in procs disallows Tuple in procs + allows using Proc as restriction (3) allows using Proc as restriction (3) + allows passing function to LibC without specifying types, using a global method allows passing function to LibC without specifying types, using a global method + types proc pointer types proc pointer casts to Proc(Nil) when specified in return type casts to Proc(Nil) when specified in return type - disallows Number in proc notation return type disallows Number in proc notation return type + finds method of object finds method of object + disallows Reference in proc notation parameter type disallows Reference in proc notation parameter type + disallows Value in proc notation parameter type disallows Value in proc notation parameter type + disallows Float in proc pointer disallows Float in proc pointer + disallows Struct in proc notation parameter type disallows Struct in proc notation parameter type disallows Int in proc pointer disallows Int in proc pointer - disallows StaticArray in proc notation return type disallows StaticArray in proc notation return type - allows implicit cast of proc to return void in non-generic restriction allows implicit cast of proc to return void in non-generic restriction - disallows Enum in proc pointer disallows Enum in proc pointer - allows invoking a function with a generic subtype (1) allows invoking a function with a generic subtype (1) - errors when using local variable with proc argument name errors when using local variable with proc argument name + sets proc type as void if explicitly told so, when using new sets proc type as void if explicitly told so, when using new + doesn't crash on constant to proc pointer doesn't crash on constant to proc pointer allows writing a function type with Proc allows writing a function type with Proc - can pass Proc(T) to Proc(Nil) in type restriction (#8964) can pass Proc(T) to Proc(Nil) in type restriction (#8964) - disallows Enum in captured block disallows Enum in captured block - allows new on proc type with less block params allows new on proc type with less block params - disallows Tuple in captured block disallows Tuple in captured block - disallows casting a proc type to one accepting same size argument but different output disallows casting a proc type to one accepting same size argument but different output - disallows Float in proc pointer disallows Float in proc pointer - allows invoking a function with a generic subtype (2) allows invoking a function with a generic subtype (2) - types proc literal hard type inference (1) types proc literal hard type inference (1) - gets pointer to lib fun without specifying types gets pointer to lib fun without specifying types + disallows casting a proc type to one accepting less arguments disallows casting a proc type to one accepting less arguments + types proc call types proc call + disallows Class in captured block disallows Class in captured block has proc literal as restriction and errors if output is different has proc literal as restriction and errors if output is different + disallows Value in procs disallows Value in procs + disallows StaticArray in proc notation return type disallows StaticArray in proc notation return type + allows passing proc type if it is typedef'd allows passing proc type if it is typedef'd + virtualizes proc type with -> (#8730) virtualizes proc type with -> (#8730) + allows passing nil as proc callback if it is a lib alias allows passing nil as proc callback if it is a lib alias + disallows Float in proc notation return type disallows Float in proc notation return type + doesn't capture closured var if using typeof doesn't capture closured var if using typeof + disallows Number in proc notation parameter type disallows Number in proc notation parameter type + allows passing union including module to proc allows passing union including module to proc + allows implicit cast of proc to return void in non-generic restriction allows implicit cast of proc to return void in non-generic restriction + virtualizes proc type (#6789) virtualizes proc type (#6789) + errors if inferred return type doesn't match return type restriction (2) errors if inferred return type doesn't match return type restriction (2) + can match *T in block argument can match *T in block argument + doesn't need to deduce type of block if return is void doesn't need to deduce type of block if return is void + types nil or proc type types nil or proc type + disallows Pointer in captured block disallows Pointer in captured block + types proc pointer with types types proc pointer with types + disallows Proc in captured block disallows Proc in captured block + errors when using macro as proc value (top-level) (#7465) errors when using macro as proc value (top-level) (#7465) + says wrong number of arguments says wrong number of arguments + *doesn't* merge Proc that returns Nil with another one that returns something else (#3655) (this was reverted) *doesn't* merge Proc that returns Nil with another one that returns something else (#3655) (this was reverted) disallows StaticArray in proc return types disallows StaticArray in proc return types - accesses T inside variadic generic (2) accesses T inside variadic generic (2) - disallows Object in proc return types disallows Object in proc return types - disallows Reference in proc pointer disallows Reference in proc pointer - disallows StaticArray in proc pointer disallows StaticArray in proc pointer - says wrong number of block params in new on proc type says wrong number of block params in new on proc type + allows passing NoReturn type for any return type (3) allows passing NoReturn type for any return type (3) disallows Proc in proc notation parameter type disallows Proc in proc notation parameter type - allows new on proc type that is a lib alias allows new on proc type that is a lib alias - says wrong number of arguments says wrong number of arguments - types proc call with return type types proc call with return type + can assign proc that returns anything to proc that returns nil, with class var (#3655) can assign proc that returns anything to proc that returns nil, with class var (#3655) + disallows Pointer in proc notation parameter type disallows Pointer in proc notation parameter type + allows using proc arg name shadowing local variable allows using proc arg name shadowing local variable + allows using Proc as restriction (1) allows using Proc as restriction (1) + says wrong number of block params in new on proc type says wrong number of block params in new on proc type can assign NoReturn proc to other proc (#3032) can assign NoReturn proc to other proc (#3032) - allows passing NoReturn type for any return type (3) allows passing NoReturn type for any return type (3) - disallows casting a proc type to one accepting less arguments disallows casting a proc type to one accepting less arguments - disallows Reference in procs disallows Reference in procs + disallows Object in proc notation parameter type disallows Object in proc notation parameter type + disallows Number in procs disallows Number in procs + allows passing NoReturn type for any return type, with Proc notation (#12126) allows passing NoReturn type for any return type, with Proc notation (#12126) + types proc pointer to instance method types proc pointer to instance method + disallows Struct in proc notation return type disallows Struct in proc notation return type uses array argument of proc arg (1) uses array argument of proc arg (1) - disallows Tuple in proc return types disallows Tuple in proc return types - disallows Int in captured block disallows Int in captured block - uses array argument of proc arg (2) uses array argument of proc arg (2) - disallows Proc in proc return types disallows Proc in proc return types - types proc pointer with a type that was never instantiated types proc pointer with a type that was never instantiated - disallows Int in proc return types disallows Int in proc return types - virtualizes proc type (#6789) virtualizes proc type (#6789) - declares an instance variable with splat in proc notation declares an instance variable with splat in proc notation - disallows Tuple in proc pointer disallows Tuple in proc pointer - allows metaclass in proc return types allows metaclass in proc return types - allows passing proc type if it is a lib alias allows passing proc type if it is a lib alias - disallows Value in proc return types disallows Value in proc return types - disallows Float in proc notation parameter type disallows Float in proc notation parameter type - allows passing function to LibC without specifying types allows passing function to LibC without specifying types - disallows Number in proc pointer disallows Number in proc pointer - types proc literal with return type (2) types proc literal with return type (2) - types proc literal with a type that was never instantiated types proc literal with a type that was never instantiated + disallows StaticArray in proc notation parameter type disallows StaticArray in proc notation parameter type + *doesn't* merge Proc that returns NoReturn with another one that returns something else (#9971) *doesn't* merge Proc that returns NoReturn with another one that returns something else (#9971) + allows metaclass in proc pointer allows metaclass in proc pointer + disallows Value in captured block disallows Value in captured block + disallows Reference in proc return types disallows Reference in proc return types + allows metaclass in proc notation parameter type allows metaclass in proc notation parameter type + has proc literal as restriction and errors if sizes are different has proc literal as restriction and errors if sizes are different + uses array argument of proc arg (4) uses array argument of proc arg (4) + errors when using local variable with proc argument name errors when using local variable with proc argument name + gets pointer to lib fun without specifying types gets pointer to lib fun without specifying types + disallows StaticArray in proc pointer disallows StaticArray in proc pointer + allows metaclass in procs allows metaclass in procs + allows metaclass in proc notation return type allows metaclass in proc notation return type + disallows Struct in captured block disallows Struct in captured block + disallows Struct in proc pointer disallows Struct in proc pointer + disallows Float in procs disallows Float in procs types a proc pointer with generic types types a proc pointer with generic types + disallows Reference in procs disallows Reference in procs + disallows Enum in captured block disallows Enum in captured block + disallows Enum in proc return types disallows Enum in proc return types + can assign proc that returns anything to proc that returns nil, with instance var (#3655) can assign proc that returns anything to proc that returns nil, with instance var (#3655) + allows new on proc type that is a lib alias allows new on proc type that is a lib alias + disallows Int in proc return types disallows Int in proc return types + says wrong return type in new on proc type says wrong return type in new on proc type + gives correct error message when proc return type is incorrect (#219) gives correct error message when proc return type is incorrect (#219) + errors when using macro as proc value (inside method) (#7465) errors when using macro as proc value (inside method) (#7465) + disallows casting a proc type to one accepting same size argument but different output disallows casting a proc type to one accepting same size argument but different output + disallows Object in captured block disallows Object in captured block + errors if inferred return type doesn't match return type restriction (1) errors if inferred return type doesn't match return type restriction (1) + can use @@cvar as pointer syntax receiver (#9239) can use @@cvar as pointer syntax receiver (#9239) + disallows Struct in procs disallows Struct in procs + disallows Proc in procs disallows Proc in procs + accesses T inside variadic generic, in proc notation accesses T inside variadic generic, in proc notation + allows invoking a function with a generic subtype (2) allows invoking a function with a generic subtype (2) disallows Class in proc notation parameter type disallows Class in proc notation parameter type - doesn't need to deduce type of block if return is void doesn't need to deduce type of block if return is void + allows passing function to LibC without specifying types, using a class method allows passing function to LibC without specifying types, using a class method + disallows Proc in proc return types disallows Proc in proc return types + uses array argument of proc arg (3) uses array argument of proc arg (3) + disallows Value in proc pointer disallows Value in proc pointer + disallows Enum in proc pointer disallows Enum in proc pointer + errors when using macro as proc value (top-level with obj) (#7465) errors when using macro as proc value (top-level with obj) (#7465) + disallows Number in proc notation return type disallows Number in proc notation return type + disallows Class in proc notation return type disallows Class in proc notation return type + disallows Pointer in proc notation return type disallows Pointer in proc notation return type disallows Enum in proc notation return type disallows Enum in proc notation return type - disallows Reference in captured block disallows Reference in captured block - disallows Struct in proc pointer disallows Struct in proc pointer - allows passing NoReturn type for any return type (2) allows passing NoReturn type for any return type (2) + accesses T and R accesses T and R + can pass Proc(T) to Proc(Nil) in type restriction (#8964) can pass Proc(T) to Proc(Nil) in type restriction (#8964) + disallows Float in proc return types disallows Float in proc return types + disallows Number in captured block disallows Number in captured block + types int proc literal types int proc literal + passes proc pointer as block with arguments passes proc pointer as block with arguments + disallows Enum in procs disallows Enum in procs + types int -> int proc call types int -> int proc call + disallows Class in proc return types disallows Class in proc return types + disallows Pointer in procs disallows Pointer in procs + disallows Tuple in captured block disallows Tuple in captured block + uses array argument of proc arg (2) uses array argument of proc arg (2) + allows passing virtual type including module to proc allows passing virtual type including module to proc ... ... - disallows Int in proc notation return type disallows Int in proc notation return type - disallows Proc in captured block disallows Proc in captured block - disallows Pointer in proc return types disallows Pointer in proc return types - has proc literal as restriction and errors if sizes are different has proc literal as restriction and errors if sizes are different - disallows Pointer in proc notation parameter type disallows Pointer in proc notation parameter type - allows passing NoReturn type for any return type, with Proc notation (#12126) allows passing NoReturn type for any return type, with Proc notation (#12126) + types proc type spec types proc type spec + disallows Int in procs disallows Int in procs + disallows Proc in proc pointer disallows Proc in proc pointer + allows passing function to LibC without specifying types allows passing function to LibC without specifying types + disallows Enum in proc notation parameter type disallows Enum in proc notation parameter type + allows metaclass in proc return types allows metaclass in proc return types + accesses T inside variadic generic accesses T inside variadic generic + allows passing NoReturn type for any return type (2) allows passing NoReturn type for any return type (2) + binds proc literal to arguments and body binds proc literal to arguments and body + disallows Float in captured block disallows Float in captured block disallows Number in proc return types disallows Number in proc return types - can pass Proc(X, T) to Proc(X, Nil) in type restriction (#8964) can pass Proc(X, T) to Proc(X, Nil) in type restriction (#8964) -Code gen: named args - calls twice with different types calls twice with different types - calls new with named arg calls new with named arg - calls with named arg and other args calls with named arg and other args - uses named args in dispatch uses named args in dispatch - sends two regular arguments as named arguments in inverted position (1) sends two regular arguments as named arguments in inverted position (1) - calls with named arg calls with named arg - overloads based on required named args, with restrictions overloads based on required named args, with restrictions - sends two regular arguments as named arguments in inverted position (2) sends two regular arguments as named arguments in inverted position (2) - calls with named arg as object method calls with named arg as object method - overloads based on required named args overloads based on required named args - sends two regular arguments as named arguments sends two regular arguments as named arguments - uses bare splat in new (2) uses bare splat in new (2) - sends one regular argument as named argument sends one regular argument as named argument -Semantic: cast - disallows casting int to pointer disallows casting int to pointer - disallows casting pointer to fun disallows casting pointer to fun - doesn't cast to unbound generic type (as) (#5927) doesn't cast to unbound generic type (as) (#5927) - doesn't crash with typeof no-type (#7441) doesn't crash with typeof no-type (#7441) - casts to same type is ok casts to same type is ok - doesn't eagerly try to check cast type (#12268) doesn't eagerly try to check cast type (#12268) - casts to incompatible type gives error casts to incompatible type gives error - disallows casting to Class disallows casting to Class - allows casting NoReturn to any type (#2132) allows casting NoReturn to any type (#2132) - casts to target type even if can't infer casted value type (obsolete) casts to target type even if can't infer casted value type (obsolete) - disallows casting fun to pointer disallows casting fun to pointer - casts from pointer to generic class gives error casts from pointer to generic class gives error - should error if can't cast even if not instantiated should error if can't cast even if not instantiated - casts to module casts to module - errors if casting nil to Object inside typeof (#2403) errors if casting nil to Object inside typeof (#2403) - can cast to metaclass (bug) can cast to metaclass (bug) - casts to base class making it virtual (2) casts to base class making it virtual (2) - doesn't error if casting to a generic type doesn't error if casting to a generic type - casts from union to compatible union casts from union to compatible union - casts to compatible type and use it casts to compatible type and use it - errors on cast inside a call that can't be instantiated errors on cast inside a call that can't be instantiated - doesn't cast to unbound generic type (as?) (#5927) doesn't cast to unbound generic type (as?) (#5927) - disallows casting to Object (#815) disallows casting to Object (#815) - casts uninstantiated generic class to itself (#10882) casts uninstantiated generic class to itself (#10882) - doesn't allow upcast of generic type var (#996) doesn't allow upcast of generic type var (#996) - casts pointer of one type to another type casts pointer of one type to another type - allows casting reference union to void pointer allows casting reference union to void pointer - allows casting object to void pointer allows casting object to void pointer - considers else to be unreachable (#9658) considers else to be unreachable (#9658) - can cast from Void* to virtual type (#3014) can cast from Void* to virtual type (#3014) - disallows casting to Reference disallows casting to Reference - casts to generic virtual type casts to generic virtual type - casts pointer to another type casts pointer to another type - can cast to metaclass (2) (#11121) can cast to metaclass (2) (#11121) - casts from union to incompatible union gives error casts from union to incompatible union gives error - casts to bigger union casts to bigger union - casts to base class making it virtual (1) casts to base class making it virtual (1) - doesn't cast to virtual primitive (bug) doesn't cast to virtual primitive (bug) + disallows casting a proc type to one accepting more arguments disallows casting a proc type to one accepting more arguments + disallows Value in proc return types disallows Value in proc return types + allows new on proc type allows new on proc type + types Proc(*T, Void) as Proc(*T, Nil) types Proc(*T, Void) as Proc(*T, Nil) + allows passing NoReturn type for any return type (1) allows passing NoReturn type for any return type (1) + accesses T inside variadic generic (2) accesses T inside variadic generic (2) + disallows Int in proc notation return type disallows Int in proc notation return type + disallows Class in proc pointer disallows Class in proc pointer + has proc literal as restriction and works has proc literal as restriction and works + can use @ivar as pointer syntax receiver (#9239) can use @ivar as pointer syntax receiver (#9239) + allows metaclass in captured block allows metaclass in captured block + allows using Proc as restriction (2) allows using Proc as restriction (2) + allows invoking a function with a generic subtype (1) allows invoking a function with a generic subtype (1) + disallows Pointer in proc pointer disallows Pointer in proc pointer +Normalize: hash literal + hoists complex element expressions, hash-like generic hoists complex element expressions, hash-like generic + normalizes empty with of normalizes empty with of + hoists complex element expressions, hash-like hoists complex element expressions, hash-like + normalizes non-empty without of normalizes non-empty without of + normalizes non-empty with of normalizes non-empty with of + hoists complex element expressions hoists complex element expressions Crystal::Repl::Interpreter - typeof - interprets typeof virtual type interprets typeof virtual type - interprets typeof metaclass type interprets typeof metaclass type - interprets typeof instance type interprets typeof instance type -Normalize: regex literal - StringLiteral - expands to const expands to const - simple simple - StringInterpolation - simple simple - options - imx imx - x x - im im - empty empty - i i + closures + closures struct and calls method on it closures struct and calls method on it + does closure without args that captures and modifies one local variable does closure without args that captures and modifies one local variable + does closure inside proc, capture proc argument does closure inside proc, capture proc argument + sets ivar of self closured struct (#12341) sets ivar of self closured struct (#12341) + closures self in proc literal (implicit self) closures self in proc literal (implicit self) + does closure inside proc does closure inside proc + does nested closure inside captured blocks does nested closure inside captured blocks + does nested closure inside methods and blocks does nested closure inside methods and blocks + does closure with pointerof local var does closure with pointerof local var + closures self in proc literal closures self in proc literal + does nested closure inside proc does nested closure inside proc + does closure inside block does closure inside block + closures self and modifies instance var closures self and modifies instance var + does closure inside const does closure inside const + gets ivar of self closured struct (#12341) gets ivar of self closured struct (#12341) + does closure without args that captures and modifies two local variables does closure without args that captures and modifies two local variables + closures def arguments closures def arguments + does next inside captured block (#12226) does next inside captured block (#12226) + closures block args after 8 bytes (the closure var) closures block args after 8 bytes (the closure var) + does closure inside block, capture block arg does closure inside block, capture block arg + reads self closured struct (#12341) reads self closured struct (#12341) + does closure with two args that captures and modifies two local variables does closure with two args that captures and modifies two local variables + does closure inside def does closure inside def + does closure inside class variable initializer does closure inside class variable initializer + passes closured struct instance var as self passes closured struct instance var as self + closures closured block arg closures closured block arg + does closure and accesses it inside block does closure and accesses it inside block + doesn't mix local vars with closured vars doesn't mix local vars with closured vars +Code gen: automatic cast + doesn't autocast number on union (#8655) doesn't autocast number on union (#8655) + casts Symbol to Enum in ivar assignment casts Symbol to Enum in ivar assignment + does multidispatch with automatic casting (1) (#8217) does multidispatch with automatic casting (1) (#8217) + casts literal float (Float32 -> Float64) casts literal float (Float32 -> Float64) + casts Int32 -> Int64 in arg restriction casts Int32 -> Int64 in arg restriction + casts literal float (Float64 -> Float32) casts literal float (Float64 -> Float32) + casts literal integer (Int32 -> Int64) casts literal integer (Int32 -> Int64) + casts literal integer (Int64 -> Int32, ok) casts literal integer (Int64 -> Int32, ok) + casts Symbol to Enum in ivar type declaration casts Symbol to Enum in ivar type declaration + casts Int32 to Int64 in ivar type declaration casts Int32 to Int64 in ivar type declaration + casts Int32 to Int64 in cvar type declaration casts Int32 to Int64 in cvar type declaration + casts literal integer (Int32 -> Float32) casts literal integer (Int32 -> Float32) + does multidispatch with automatic casting (3) does multidispatch with automatic casting (3) + casts Int32 to Int64 in lvar assignment casts Int32 to Int64 in lvar assignment + casts literal integer (Int32 -> Float64) casts literal integer (Int32 -> Float64) + casts Int32 to Int64 in ivar assignment casts Int32 to Int64 in ivar assignment + casts Int32 to Int64 in ivar type declaration in generic casts Int32 to Int64 in ivar type declaration in generic + casts integer variable to larger type (#9565) casts integer variable to larger type (#9565) + casts symbol literal to enum casts symbol literal to enum + does multidispatch with automatic casting (2) (#8217) does multidispatch with automatic casting (2) (#8217) + casts Int32 to Int64 in cvar assignment casts Int32 to Int64 in cvar assignment +Codegen: special vars + allows with primitive allows with primitive + codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block + codegens after block 2 codegens after block 2 + codegens with default argument codegens with default argument + allows with struct allows with struct + codegens $? codegens $? + preserves special vars in macro expansion with call with default arguments (#824) preserves special vars in macro expansion with call with default arguments (#824) + codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) + codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block + works lazily works lazily works lazily works lazily works lazily works lazily works lazily works lazily works lazily works lazily + codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) + codegens $~ codegens $~ + codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block + preserves special vars if initialized inside block (#2194) preserves special vars if initialized inside block (#2194) + codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) + codegens $~ two levels codegens $~ two levels + codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) +Code gen: op assign + evaluates exps once (#3398) evaluates exps once (#3398) + evaluates exps once, [] (#3398) evaluates exps once, [] (#3398) +Semantic: union + types union when both obj and arg are union types union when both obj and arg are union + errors if instantiates union errors if instantiates union + types union types union + can reopen Union can reopen Union + commutativity + generic module instance v.s. extending generic module instance metaclass generic module instance v.s. extending generic module instance metaclass + uninstantiated generic super-metaclass v.s. uninstantiated generic sub-metaclass uninstantiated generic super-metaclass v.s. uninstantiated generic sub-metaclass + module v.s. including module module v.s. including module + generic module instance v.s. including generic module instance generic module instance v.s. including generic module instance + generic module instance v.s. including module generic module instance v.s. including module + module v.s. including generic module instance module v.s. including generic module instance + virtual metaclass v.s. generic subclass instance metaclass virtual metaclass v.s. generic subclass instance metaclass + superclass v.s. uninstantiated generic subclass superclass v.s. uninstantiated generic subclass + module v.s. extending generic module instance metaclass module v.s. extending generic module instance metaclass + merges types in the same hierarchy with Union merges types in the same hierarchy with Union + doesn't crash with union of no-types (#5805) doesn't crash with union of no-types (#5805) + doesn't run virtual lookup on unbound unions (#9173) doesn't run virtual lookup on unbound unions (#9173) + looks up type in union type with free var looks up type in union type with free var + can iterate T can iterate T + can use Union in type restriction (#2988) can use Union in type restriction (#2988) + finds method in Object finds method in Object + types union when arg is union types union when arg is union + doesn't virtualize union elements (#7814) doesn't virtualize union elements (#7814) + treats void as nil in union treats void as nil in union + supports macro if inside union supports macro if inside union + types union when obj is union types union when obj is union + types union of classes types union of classes + assigns to union and keeps new union type in call assigns to union and keeps new union type in call + can reopen Union and access T can reopen Union and access T + finds method in Value finds method in Value + types union of same type types union of same type +Codegen: until + codegens until codegens until +context + does includes self on classes does includes self on classes + can get context of empty def can get context of empty def + consider different instances of def consider different instances of def + can get context in generic class can get context in generic class + includes last call includes last call + can get context inside initialize can get context inside initialize + can get context in file private method can get context in file private method + does includes regex special variables does includes regex special variables + use type filters from if var use type filters from if var + can get context of nested yielded block can get context of nested yielded block + includes top level vars includes top level vars + can get context in file private module can get context in file private module + can handle union types can handle union types + can get context inside class methods can get context inside class methods + does not includes temp variables does not includes temp variables + includes args includes args + includes assignments includes assignments + can get context of empty yielded block can get context of empty yielded block + can get context inside a module can get context inside a module + includes block args includes block args + can get context in contained class' class method can get context in contained class' class method + use type filters from is_a? use type filters from is_a? + can get context of yielded block can get context of yielded block + can display text output can display text output + does includes args, instance vars, local variables and expressions on instance methods does includes args, instance vars, local variables and expressions on instance methods + can't get context from uncalled method can't get context from uncalled method + can display json output can display json output +Crystal::Codegen::Target + normalizes triples normalizes triples + parses incomplete triples parses incomplete triples + parses freebsd version parses freebsd version +Semantic: nilable cast + doesn't introduce type filter for nilable cast object (#12661) doesn't introduce type filter for nilable cast object (#12661) + types as? with NoReturn types as? with NoReturn + casts to module casts to module + doesn't crash with typeof no-type (#7441) doesn't crash with typeof no-type (#7441) + types as? types as? + types as? with union types as? with union + types as? with nil types as? with nil + does upcast does upcast +Semantic: special vars + infers $~ infers $~ + infers when assigning inside block infers when assigning inside block + infers $? infers $? + infers in block infers in block + types $~ when not defined as no return types $~ when not defined as no return + infers after block infers after block + types $~ when not defined as no return (2) types $~ when not defined as no return (2) + infers in block with nested block infers in block with nested block + errors if assigning $? at top level errors if assigning $? at top level + errors if assigning $~ at top level errors if assigning $~ at top level + types $? when not defined as no return types $? when not defined as no return + types $? when not defined as no return (2) types $? when not defined as no return (2) +Crystal::CrystalPath + finds "./test_folder/*" finds "./test_folder/*" + finds "test_files" finds "test_files" + doesn't finds "./crystal_path_spec.cr" doesn't finds "./crystal_path_spec.cr" + finds "foo.cr" finds "foo.cr" + finds "../test_folder" finds "../test_folder" + finds "./test_folder/file_three.cr" finds "./test_folder/file_three.cr" + doesn't finds "./crystal_path_spec" doesn't finds "./crystal_path_spec" + finds "test_files/file_one" finds "test_files/file_one" + doesn't finds "../crystal_path/test_files/file_one" doesn't finds "../crystal_path/test_files/file_one" + includes 'lib' by default includes 'lib' by default + doesn't finds "test_files/missing_file.cr" doesn't finds "test_files/missing_file.cr" + doesn't finds "file_two.cr" doesn't finds "file_two.cr" + .expand_paths .expand_paths + finds "test_files/**" finds "test_files/**" + finds "other_test_files" finds "other_test_files" + finds "crystal_path_spec" finds "crystal_path_spec" + finds "test_files/file_one" finds "test_files/file_one" + finds "test_files/file_one.cr" finds "test_files/file_one.cr" + #each_file_expansion + foo/bar foo/bar + ./foo ./foo + foo.cr foo.cr + foo/bar/baz foo/bar/baz + ./foo/bar ./foo/bar + ./foo/bar/baz ./foo/bar/baz + foo.cr/bar.cr foo.cr/bar.cr + foo.cr/bar foo.cr/bar + foo foo + ./foo.cr ./foo.cr + finds "./file_two.cr" finds "./file_two.cr" + finds "test_files/file_three" finds "test_files/file_three" + doesn't finds "build/reproducible-path/crystal-1.14.0+dfsg/spec/compiler/crystal_path/crystal_path_spec.cr" doesn't finds "build/reproducible-path/crystal-1.14.0+dfsg/spec/compiler/crystal_path/crystal_path_spec.cr" + finds "test_files/file_four" finds "test_files/file_four" + finds "test_files/yet_another" finds "test_files/yet_another" + overrides path with environment variable overrides path with environment variable + doesn't finds "test_folder/*" doesn't finds "test_folder/*" + doesn't finds "test_folder/file_three.cr" doesn't finds "test_folder/file_three.cr" + finds "test_files/*" finds "test_files/*" + doesn't finds "../../src/file_three" doesn't finds "../../src/file_three" + finds "../**" finds "../**" + finds "test_files/another" finds "test_files/another" +Semantic: did you mean + doesn't suggest for operator doesn't suggest for operator + suggests a better alternative to logical operators (#2715) suggests a better alternative to logical operators (#2715) + suggests for class variable suggests for class variable + suggest that there might be a typo for an initialize method with overload suggest that there might be a typo for an initialize method with overload + says did you mean for instance var in subclass says did you mean for instance var in subclass + says did you mean for one mistake in short word in instance method says did you mean for one mistake in short word in instance method + says did you mean for nested class says did you mean for nested class + says did you mean for variable says did you mean for variable + says did you mean for class says did you mean for class + suggest that there might be a typo for an initialize method suggest that there might be a typo for an initialize method + says did you mean for global method without parenthesis says did you mean for global method without parenthesis + says did you mean for two mistakes in long word in instance method says did you mean for two mistakes in long word in instance method + says did you mean for named argument says did you mean for named argument + says did you mean finds most similar in type says did you mean finds most similar in type + says did you mean for instance var says did you mean for instance var + doesn't suggest when declaring var inside macro (#466) doesn't suggest when declaring var inside macro (#466) + doesn't suggest when declaring var with suffix if and using it (#946) doesn't suggest when declaring var with suffix if and using it (#946) + says did you mean for global method with parenthesis says did you mean for global method with parenthesis + says did you mean finds most similar in def says did you mean finds most similar in def + suggest that there might be a typo for an initialize method in inherited class suggest that there might be a typo for an initialize method in inherited class + says did you mean in instance var declaration says did you mean in instance var declaration Semantic: instance var - doesn't error when using generic in generic type because guessed elsewhere doesn't error when using generic in generic type because guessed elsewhere - errors if declaring var in Union(*T) errors if declaring var in Union(*T) - doesn't error if not calling super but initializing all variables doesn't error if not calling super but initializing all variables - declares instance var in module, inherits to type recursively declares instance var in module, inherits to type recursively - doesn't error if not initializing variables but calling super in parent parent doesn't error if not initializing variables but calling super in parent parent - types generic instance as virtual type if generic type has subclasses (#3805) types generic instance as virtual type if generic type has subclasses (#3805) - errors if not initializing super variable in generic errors if not initializing super variable in generic - guesses from splat (2) (#3149) guesses from splat (2) (#3149) - guesses from array literal with of, with subclass guesses from array literal with of, with subclass - declares instance var of generic type, with generic type declares instance var of generic type, with generic type - doesn't error when redeclaring subclass variable with the same type doesn't error when redeclaring subclass variable with the same type - doesn't duplicate instance var in subclass doesn't duplicate instance var in subclass - infers type from && infers type from && - infers type from array literal with of infers type from array literal with of - infers from Pointer.malloc infers from Pointer.malloc - infers from assign to local var in generic type (#2467) infers from assign to local var in generic type (#2467) - errors if declaring var in Enum errors if declaring var in Enum - infers type from array literal with of metaclass infers type from array literal with of metaclass - solves instance var initializer in metaclass context (#5876) solves instance var initializer in metaclass context (#5876) - infers type from lib out (1) infers type from lib out (1) - doesn't infer unbound generic type on non-generic call (#6390) doesn't infer unbound generic type on non-generic call (#6390) - infers type from argument with restriction, in generic infers type from argument with restriction, in generic - infers from Pointer.null infers from Pointer.null + doesn't consider var as nilable if conditionally assigned inside initialize, but has initializer (#3669) doesn't consider var as nilable if conditionally assigned inside initialize, but has initializer (#3669) + infers type from custom generic hash literal infers type from custom generic hash literal + transfers initializer from generic module to class transfers initializer from generic module to class + infers type from char literal infers type from char literal + is more permissive with macro def initialize, other initialize is more permissive with macro def initialize, other initialize + infers from class method that has type annotation, with multiple overloads matching, all with the same type infers from class method that has type annotation, with multiple overloads matching, all with the same type + declares instance var of generic type declares instance var of generic type + doesn't infer type to be nilable if using self.class in call in assign doesn't infer type to be nilable if using self.class in call in assign + declares instance var of generic module (2) declares instance var of generic module (2) + doesn't complain in second part of #2575 doesn't complain in second part of #2575 + obeys super module initialize (#456) obeys super module initialize (#456) errors if not initializing super variables errors if not initializing super variables - infers type from regex literal with interpolation infers type from regex literal with interpolation - infers type from all call matches infers type from all call matches - infers type for generic class, with lib call infers type for generic class, with lib call - infers type from custom hash literal infers type from custom hash literal - can't infer type from initializer in generic module type can't infer type from initializer in generic module type - infers type from named tuple literal infers type from named tuple literal - infers nilable instance var of generic type infers nilable instance var of generic type - guesses virtual hash type (2) (#5342) guesses virtual hash type (2) (#5342) - errors if not initialized in all initialize errors if not initialized in all initialize - errors if adds instance variable to Object via guess via included module errors if adds instance variable to Object via guess via included module - considers var as assigned in multi-assign considers var as assigned in multi-assign - infers type from custom array literal in generic infers type from custom array literal in generic - can guess the type from double-splat argument with double-splatted type variable can guess the type from double-splat argument with double-splatted type variable - infers from method on integer literal, with type annotation infers from method on integer literal, with type annotation + infers type from tuple literal infers type from tuple literal + infers type to be nilable if self is used before assigning to a variable infers type to be nilable if self is used before assigning to a variable infers type from two literals infers type from two literals - infers type from as infers type from as - infers from another instance var infers from another instance var - doesn't infer unbound generic type on generic method called from generic's subclass doesn't infer unbound generic type on generic method called from generic's subclass - infers nilable instance var of generic module infers nilable instance var of generic module - infers type for generic class, with begin infers type for generic class, with begin - infers type from ! infers type from ! - doesn't check call of non-self instance (#4830) doesn't check call of non-self instance (#4830) - infers type from begin infers type from begin + declares instance var with initial value declares instance var with initial value + infers from class method that refers to constant infers from class method that refers to constant + infers type from block argument without restriction infers type from block argument without restriction + infers type from responds_to? infers type from responds_to? + errors if declaring instance var and turns out to be nilable, in generic module type in generic type errors if declaring instance var and turns out to be nilable, in generic module type in generic type + doesn't infer unbound generic type on non-generic call (#6390) doesn't infer unbound generic type on non-generic call (#6390) + doesn't consider instance var as nilable if assigned before self access (#4981) doesn't consider instance var as nilable if assigned before self access (#4981) + errors if declaring instance variable in module included in Object errors if declaring instance variable in module included in Object + inferrs Proc(Void) to Proc(Nil) inferrs Proc(Void) to Proc(Nil) + declares as named tuple declares as named tuple + cannot guess the type from double-splat argument with not double-splatted type cannot guess the type from double-splat argument with not double-splatted type + doesn't complain if declared type is recursive alias that's nilable doesn't complain if declared type is recursive alias that's nilable + errors if declaring var in Int32 errors if declaring var in Int32 infers from new with return type infers from new with return type - declares instance var of generic type, with virtual metaclass declares instance var of generic type, with virtual metaclass - doesn't solve instance var initializer in instance context (1) (#5876) doesn't solve instance var initializer in instance context (1) (#5876) - infers type for generic class, with if infers type for generic class, with if - guesses inside macro expression guesses inside macro expression - infers type for generic class, with literal infers type for generic class, with literal - infers type from path that is a constant infers type from path that is a constant - declares instance var of generic module declares instance var of generic module - infers type from case infers type from case - errors if declaring var in Proc(*T, R) errors if declaring var in Proc(*T, R) - errors if declaring generic type without type vars errors if declaring generic type without type vars - can guess the type from double-splat argument with double-splatted type can guess the type from double-splat argument with double-splatted type - can guess the type from splat argument with splatted type variable can guess the type from splat argument with splatted type variable - infers type to be nilable if self is used in same assign infers type to be nilable if self is used in same assign - doesn't infer from class method with multiple statements and return, on non-easy return doesn't infer from class method with multiple statements and return, on non-easy return - guesses from as.(typeof(...)) guesses from as.(typeof(...)) - shouldn't error when accessing instance var in initialized that's always initialized (#2953) shouldn't error when accessing instance var in initialized that's always initialized (#2953) - infers type from hash literal in generic type infers type from hash literal in generic type - declares instance var of generic type, with metaclass declares instance var of generic type, with metaclass - errors if declaring var in Int errors if declaring var in Int - doesn't error if declaring instance var and doesn't out to be nilable, in generic module type doesn't error if declaring instance var and doesn't out to be nilable, in generic module type - cannot guess the type from splat argument with not splatted type cannot guess the type from splat argument with not splatted type - infers type from instance_sizeof infers type from instance_sizeof - doesn't solve instance var initializer in instance context (2) (#5876) doesn't solve instance var initializer in instance context (2) (#5876) - errors if declaring var in Float errors if declaring var in Float - infers type by removing nil from || left side infers type by removing nil from || left side - declares instance var of generic type, with tuple declares instance var of generic type, with tuple - doesn't error if not initializing variables but calling previous_def (#3210) doesn't error if not initializing variables but calling previous_def (#3210) - looks up return type restriction in defining type, not instantiated type (#11961) looks up return type restriction in defining type, not instantiated type (#11961) - ignores redefined initialize (#456) ignores redefined initialize (#456) - infers type for generic class, with T.new and literal infers type for generic class, with T.new and literal - doesn't crash when inferring from new without matches (#2538) doesn't crash when inferring from new without matches (#2538) - doesn't error if not initializing variables but calling super doesn't error if not initializing variables but calling super - infers from new with return type in generic type infers from new with return type in generic type doesn't infer type to be nilable if using self.class doesn't infer type to be nilable if using self.class - allows nil instance var because it's a generic type allows nil instance var because it's a generic type - guesses virtual array type (3) (#5342) guesses virtual array type (3) (#5342) - infers type from assign (1) infers type from assign (1) - doesn't error if calling initialize from another initialize (2) doesn't error if calling initialize from another initialize (2) - errors when typing an instance variable inside a method errors when typing an instance variable inside a method - infers type for generic class, with T.new infers type for generic class, with T.new - declares instance var declares instance var - declares instance var with self, on generic declares instance var with self, on generic - doesn't infer for subclass if assigns another type (1) doesn't infer for subclass if assigns another type (1) - infers type for generic class, with case infers type for generic class, with case - infers type from array literal in generic type infers type from array literal in generic type - can't infer type from initializer can't infer type from initializer + infers type for non-generic class, with assign infers type for non-generic class, with assign + errors if declaring instance var and turns out to be nilable, in generic module type errors if declaring instance var and turns out to be nilable, in generic module type + doesn't crash on recursive method call doesn't crash on recursive method call infers from another instance var with type declaration infers from another instance var with type declaration - infers type from assign (2) infers type from assign (2) - errors if declaring var in Int32 errors if declaring var in Int32 - doesn't error when using generic because guessed elsewhere doesn't error when using generic because guessed elsewhere - guesses virtual array type (3) (#5342) guesses virtual array type (3) (#5342) - infers type from lib variable infers type from lib variable - doesn't infer generic type without type argument inside generic doesn't infer generic type without type argument inside generic - uses virtual types in fun uses virtual types in fun - doesn't error if uses typeof(@var) doesn't error if uses typeof(@var) - errors if declaring var in Value errors if declaring var in Value - errors if declaring var in Number errors if declaring var in Number + doesn't check call of non-self instance (#4830) doesn't check call of non-self instance (#4830) + infers type for generic class, with assign (1) infers type for generic class, with assign (1) infers type from hash literal from elements infers type from hash literal from elements - doesn't error if not initializing variables but calling super for module doesn't error if not initializing variables but calling super for module - doesn't error if calling initialize from another initialize (1) doesn't error if calling initialize from another initialize (1) - infers type from hash literal with literals in generic type infers type from hash literal with literals in generic type + infers type for generic module infers type for generic module + doesn't error when using generic because guessed elsewhere doesn't error when using generic because guessed elsewhere + infers type from regex literal with interpolation infers type from regex literal with interpolation + guesses inside macro expression guesses inside macro expression + infer from class method where new is redefined infer from class method where new is redefined + declares instance var with initial value, with subclass declares instance var with initial value, with subclass + infers type for generic class, with if infers type for generic class, with if + infers type from ! infers type from ! + infers from class method that has number literal infers from class method that has number literal + can't infer type from initializer in generic module type can't infer type from initializer in generic module type + says can't infer (#2536) says can't infer (#2536) + errors if declaring var in Float errors if declaring var in Float + infers type from array literal with literals in generic type infers type from array literal with literals in generic type + declares instance var of generic module from non-generic module declares instance var of generic module from non-generic module declares instance var of generic class after reopen declares instance var of generic class after reopen - errors when assigning instance variable at top level block errors when assigning instance variable at top level block - guesses virtual hash type (1) (#5342) guesses virtual hash type (1) (#5342) - infers from class method that has type annotation, in generic class infers from class method that has type annotation, in generic class - doesn't error if initializes via super in macro def doesn't error if initializes via super in macro def + infers type from lib variable infers type from lib variable errors when using Class in generic type errors when using Class in generic type - errors if declaring instance variable in module included in Object errors if declaring instance variable in module included in Object - doesn't error if not initialized in macro def but outside it doesn't error if not initialized in macro def but outside it - can't infer type of generic method that returns self (#5383) can't infer type of generic method that returns self (#5383) - infers type from included module, outside def infers type from included module, outside def - infers type to be nilable if self is used before assigning to a variable infers type to be nilable if self is used before assigning to a variable - infers type to be nilable if not initialized infers type to be nilable if not initialized - is more permissive with macro def initialize is more permissive with macro def initialize - infers type for non-generic class, with assign infers type for non-generic class, with assign - declares instance var of generic type, with splat declares instance var of generic type, with splat - infers type from new expression infers type from new expression - infers type in multi assign infers type in multi assign - says can't infer type if only nil was assigned says can't infer type if only nil was assigned - infers type from custom hash literal in generic infers type from custom hash literal in generic - cannot guess type from argument assigned in body cannot guess type from argument assigned in body - inferrs Proc(Void) to Proc(Nil) inferrs Proc(Void) to Proc(Nil) + errors if declaring var in Reference errors if declaring var in Reference + is more permissive with macro def initialize, bug with named args is more permissive with macro def initialize, bug with named args + guesses from array literal with of, with subclass guesses from array literal with of, with subclass + uses virtual types in fun uses virtual types in fun + infers type from ||= infers type from ||= + infers type from custom generic array literal infers type from custom generic array literal + infers type from regex literal infers type from regex literal doesn't error if not initializing variables but calling previous_def (2) (#3210) doesn't error if not initializing variables but calling previous_def (2) (#3210) - doesn't infer type from redefined method doesn't infer type from redefined method - infers type to be non-nilable if initialized in all initialize infers type to be non-nilable if initialized in all initialize - infers from Pointer.null in generic type infers from Pointer.null in generic type + infers from Pointer.malloc infers from Pointer.malloc + doesn't crash when inferring from new without matches (#2538) doesn't crash when inferring from new without matches (#2538) + infers type from assign (2) infers type from assign (2) + infers type from symbol literal infers type from symbol literal + infers type from hash literal with of infers type from hash literal with of + infers type from custom array literal infers type from custom array literal + infers type from bool literal infers type from bool literal + infers type from lib out (1) infers type from lib out (1) + infers type in multi assign infers type in multi assign + errors if declaring generic type without type vars errors if declaring generic type without type vars + doesn't error when redeclaring subclass variable with the same type doesn't error when redeclaring subclass variable with the same type + infers from another instance var infers from another instance var + doesn't solve instance var initializer in instance context (2) (#5876) doesn't solve instance var initializer in instance context (2) (#5876) + can type ivar from class inherited by generic class (#5281) can type ivar from class inherited by generic class (#5281) + errors if declaring var in Value errors if declaring var in Value + guesses from splat (2) (#3149) guesses from splat (2) (#3149) can't infer type from initializer in non-generic module can't infer type from initializer in non-generic module - infers from new with return type returning generic infers from new with return type returning generic - accepts overriding inherited instance variable with compatible type accepts overriding inherited instance variable with compatible type - infers from another instance var in generic type with type declaration infers from another instance var in generic type with type declaration - instance variables initializers are used in class variables initialized objects (#3988) instance variables initializers are used in class variables initialized objects (#3988) - infers from assign to local var (#2467) infers from assign to local var (#2467) - doesn't if declaring nilable instance var and turns out to be nilable doesn't if declaring nilable instance var and turns out to be nilable + errors if not initializing super variables (2) errors if not initializing super variables (2) + infers from class method that has type annotation, with overload infers from class method that has type annotation, with overload + infers type from as? infers type from as? + infers type from block argument infers type from block argument + infers type for generic class, with case infers type for generic class, with case + errors when overriding inherited instance variable with incompatible type errors when overriding inherited instance variable with incompatible type + infers type from redefined method if calls previous_def infers type from redefined method if calls previous_def + declares instance var of generic type, with splat inside Tuple declares instance var of generic type, with splat inside Tuple + infers type from && infers type from && + guesses virtual array type (3) (#5342) guesses virtual array type (3) (#5342) + infers type from array literal from its literals infers type from array literal from its literals + doesn't infer from class method with multiple statements and return, on non-easy return (2) doesn't infer from class method with multiple statements and return, on non-easy return (2) + infers from restriction using virtual type infers from restriction using virtual type + infers type for generic class, with T.new infers type for generic class, with T.new + infers type from begin infers type from begin + errors if declaring var in Int errors if declaring var in Int can type ivar from module included by generic class (#5281) can type ivar from module included by generic class (#5281) - says can't infer type if only nil was assigned, in generic type says can't infer type if only nil was assigned, in generic type - doesn't crash on #3580 doesn't crash on #3580 - infers from method in generic type, with type annotation infers from method in generic type, with type annotation - infers in multiple assign for tuple type (1) infers in multiple assign for tuple type (1) - declares instance var of generic type, with no type parameter declares instance var of generic type, with no type parameter - declares instance var of generic type subclass declares instance var of generic type subclass - doesn't error if not initializes in all initialize because declared as nilable doesn't error if not initializes in all initialize because declared as nilable - says can't infer (#2536) says can't infer (#2536) - errors with macro def but another def doesn't initialize all errors with macro def but another def doesn't initialize all - doesn't error if initializing var in superclass, and then empty initialize doesn't error if initializing var in superclass, and then empty initialize - infers type from array literal with literals in generic type infers type from array literal with literals in generic type - guesses inside macro if guesses inside macro if - errors if declaring var in StaticArray(T, N) errors if declaring var in StaticArray(T, N) - infers type from if infers type from if + infers type from self (#2575) infers type from self (#2575) + doesn't error if uses typeof(@var) doesn't error if uses typeof(@var) + declares instance var in module, inherits to type recursively declares instance var in module, inherits to type recursively + guesses virtual array type (3) (#5342) guesses virtual array type (3) (#5342) + infers from new with return type returning generic infers from new with return type returning generic + errors if not initializing super variables (3) errors if not initializing super variables (3) + errors if finally not initialized in macro def errors if finally not initialized in macro def is more permissive with macro def initialize, multiple is more permissive with macro def initialize, multiple - infers type from custom generic array literal infers type from custom generic array literal - doesn't error if not initializing variables but calling super for generic module doesn't error if not initializing variables but calling super for generic module - doesn't infer from class method with multiple statements and return, on non-easy return (2) doesn't infer from class method with multiple statements and return, on non-easy return (2) - can't infer type from initializer in generic class type can't infer type from initializer in generic class type - infers type from literal outside def with initialize and type restriction infers type from literal outside def with initialize and type restriction - errors when using Class (#2605) errors when using Class (#2605) - errors if adds instance variable to Object via guess errors if adds instance variable to Object via guess - errors if declaring var in Reference errors if declaring var in Reference - can declare type even if included module has a guessed var can declare type even if included module has a guessed var - infers type from custom array literal infers type from custom array literal - instance variable inherited from multiple parents - with compatible type - accepts module and module, with definitions accepts module and module, with definitions - module and class, with declarations module and class, with declarations - module and class, with declarations (2) module and class, with declarations (2) - module and class, with declarations (3) module and class, with declarations (3) - accepts module and module, with declarations accepts module and module, with declarations - module and class, with definitions module and class, with definitions - with incompatible type - errors module and module, with declarations errors module and module, with declarations - module and class, with declarations module and class, with declarations - module and class, with definitions module and class, with definitions - errors module and module, with definitions errors module and module, with definitions - infers from class method that has type annotation, with overload infers from class method that has type annotation, with overload - doesn't complain in second part of #2575 doesn't complain in second part of #2575 - infers type from as? infers type from as? - errors if finally not initialized in macro def errors if finally not initialized in macro def - infers type from number literal infers type from number literal - errors when redeclaring subclass variable with a different type errors when redeclaring subclass variable with a different type - errors on undefined constant errors on undefined constant - infers type from ||= infers type from ||= - infers type from path that is a type infers type from path that is a type - infers from generic class method that has type annotation infers from generic class method that has type annotation - errors when overriding inherited instance variable with incompatible type errors when overriding inherited instance variable with incompatible type - guesses from new on abstract class guesses from new on abstract class - infers type from ||= inside another assignment infers type from ||= inside another assignment - doesn't infer for subclass if assigns another type (2) doesn't infer for subclass if assigns another type (2) - declares instance var with initial value declares instance var with initial value - declares instance var of generic class declares instance var of generic class - infers type from argument default value infers type from argument default value - cannot guess the type from double-splat argument with not double-splatted type cannot guess the type from double-splat argument with not double-splatted type - declares instance var of generic type, with static array declares instance var of generic type, with static array - uses virtual types in union uses virtual types in union - can type ivar from class inherited by generic class (#5281) can type ivar from class inherited by generic class (#5281) - guesses virtual array type (2) (#5342) guesses virtual array type (2) (#5342) - infers from class method that has type annotation infers from class method that has type annotation - infers type from is_a? infers type from is_a? - doesn't consider instance var as nilable if assigned before self access (#4981) doesn't consider instance var as nilable if assigned before self access (#4981) - infer from class method with multiple statements and return infer from class method with multiple statements and return - infers from generic class method that has type annotation, without instantiating infers from generic class method that has type annotation, without instantiating - guesses from as.(typeof(...)) in generic type guesses from as.(typeof(...)) in generic type - doesn't error if not initializing variables but calling super and previous_def doesn't error if not initializing variables but calling super and previous_def - infers type from lib fun call infers type from lib fun call - infers type from symbol literal infers type from symbol literal - allow usage of instance variable initializer from instance variable initializer allow usage of instance variable initializer from instance variable initializer - infers type from array literal from its literals infers type from array literal from its literals - errors if declaring instance var and turns out to be nilable errors if declaring instance var and turns out to be nilable - gives correct error when trying to use Int as an instance variable type gives correct error when trying to use Int as an instance variable type - infers type for generic class, with assign (2) infers type for generic class, with assign (2) - errors if not initializing super variables (2) errors if not initializing super variables (2) + errors if declaring var in Class errors if declaring var in Class + doesn't error when using generic in generic type because guessed elsewhere doesn't error when using generic in generic type because guessed elsewhere + errors if declaring var in Number errors if declaring var in Number + doesn't infer unbound generic type on generic method called from generic's subclass, metaclass context doesn't infer unbound generic type on generic method called from generic's subclass, metaclass context + declares instance var of generic module declares instance var of generic module doesn't combine union of Number and Number subclass (#5073) doesn't combine union of Number and Number subclass (#5073) - ignores super module initialize (#456) ignores super module initialize (#456) - infers from class method that has type annotation, with multiple overloads matching, all with the same type infers from class method that has type annotation, with multiple overloads matching, all with the same type + declares instance var of generic type, with union declares instance var of generic type, with union doesn't complain if not initialized in one initialize, but has initializer (#2465) doesn't complain if not initialized in one initialize, but has initializer (#2465) - infers type from lib out (2) infers type from lib out (2) + cannot guess the type from splat argument with not splatted type cannot guess the type from splat argument with not splatted type + errors if unknown ivar through macro (#4050) errors if unknown ivar through macro (#4050) + infers type from argument default value infers type from argument default value + guesses virtual hash type (1) (#5342) guesses virtual hash type (1) (#5342) + errors on undefined instance var and subclass calling super errors on undefined instance var and subclass calling super + errors if declaring instance var and turns out to be nilable, in generic type errors if declaring instance var and turns out to be nilable, in generic type + errors if declaring var in NamedTuple(T) errors if declaring var in NamedTuple(T) + looks up return type restriction in defining type, not instantiated type (#11961) looks up return type restriction in defining type, not instantiated type (#11961) + guesses from new on abstract class guesses from new on abstract class + declares with `self` declares with `self` infers type for generic class, with && infers type for generic class, with && - infers type for generic class, with assign (1) infers type for generic class, with assign (1) - declares instance var which appears in initialize declares instance var which appears in initialize - infers type from enum member infers type from enum member - errors if not initializing super variables (3) errors if not initializing super variables (3) - declares instance var of generic type declares instance var of generic type - infers type from string literal infers type from string literal + declares instance var with self, on generic declares instance var with self, on generic + instance variables initializers are used in class variables initialized objects (#3988) instance variables initializers are used in class variables initialized objects (#3988) + infers type from hash literal with literals in generic type infers type from hash literal with literals in generic type + infers type from literal outside def infers type from literal outside def + doesn't infer for subclass if assigns another type (1) doesn't infer for subclass if assigns another type (1) + doesn't error if not initializing variables but calling super in parent parent doesn't error if not initializing variables but calling super in parent parent + doesn't error when using Class but specifying type doesn't error when using Class but specifying type + doesn't error if not initializing variables but calling super doesn't error if not initializing variables but calling super + doesn't error if not calling super but initializing all variables doesn't error if not calling super but initializing all variables + infers from Pointer.malloc with two arguments infers from Pointer.malloc with two arguments + infers type by removing nil from || left side infers type by removing nil from || left side + declares instance var of generic class declares instance var of generic class + errors with macro def but another def doesn't initialize all errors with macro def but another def doesn't initialize all + infers from generic class method that has type annotation infers from generic class method that has type annotation doesn't consider self.initialize as initializer (#3239) doesn't consider self.initialize as initializer (#3239) - declares instance var with initial value, with subclass declares instance var with initial value, with subclass - infers type from string interpolation infers type from string interpolation + gives correct error when trying to use Int as an instance variable type gives correct error when trying to use Int as an instance variable type + can't infer type from initializer can't infer type from initializer + errors if declaring var in Proc(*T, R) errors if declaring var in Proc(*T, R) + infers type from unless infers type from unless + infers type for generic class, with assign (2) infers type for generic class, with assign (2) + errors if declaring var in StaticArray(T, N) errors if declaring var in StaticArray(T, N) infers type from lib out (3) infers type from lib out (3) + declares instance var in module, inherits to type declares instance var in module, inherits to type + infers type to be nilable if self is used in same assign infers type to be nilable if self is used in same assign + declares instance var which appears in initialize declares instance var which appears in initialize + guesses from hash literal with of, with subclass guesses from hash literal with of, with subclass + declares instance var declares instance var + infers from class method that has type annotation infers from class method that has type annotation + infers type for generic class, with T.new and literal infers type for generic class, with T.new and literal + solves instance var initializer in metaclass context (#5876) solves instance var initializer in metaclass context (#5876) + doesn't error if calling initialize from another initialize (2) doesn't error if calling initialize from another initialize (2) + infers type from || infers type from || + doesn't solve instance var initializer in instance context (3) (#5876) doesn't solve instance var initializer in instance context (3) (#5876) + can guess the type from splat argument with splatted type variable can guess the type from splat argument with splatted type variable + doesn't duplicate instance var in subclass doesn't duplicate instance var in subclass + infers type from array literal in generic type infers type from array literal in generic type + infers type from included module, outside def infers type from included module, outside def + infers type from sizeof infers type from sizeof + infer from class method with multiple statements and return infer from class method with multiple statements and return + infers type from path that is a type infers type from path that is a type + guesses virtual array type (1) (#5342) guesses virtual array type (1) (#5342) + doesn't error if not initializing nilable var in subclass doesn't error if not initializing nilable var in subclass + infers type from offsetof infers type from offsetof + allows nil instance var because it's a generic type allows nil instance var because it's a generic type + can guess the type from double-splat argument with double-splatted type can guess the type from double-splat argument with double-splatted type + errors if adds instance variable to Object via guess via included module errors if adds instance variable to Object via guess via included module + infers nilable instance var of generic module infers nilable instance var of generic module + errors if declaring var in Enum errors if declaring var in Enum + guesses inside macro if guesses inside macro if + infers type from custom hash literal infers type from custom hash literal + infers type for generic class, with literal infers type for generic class, with literal + errors if declaring var in Pointer(T) errors if declaring var in Pointer(T) + doesn't infer for subclass if assigns another type (2) doesn't infer for subclass if assigns another type (2) + infers type for generic class, with lib call infers type for generic class, with lib call + errors if declaring instance var and turns out to be nilable errors if declaring instance var and turns out to be nilable + infers type from custom hash literal in generic infers type from custom hash literal in generic + doesn't solve instance var initializer in instance context (1) (#5876) doesn't solve instance var initializer in instance context (1) (#5876) + doesn't error if not initializing variables but calling super for module doesn't error if not initializing variables but calling super for module + infers type from hash literal in generic type infers type from hash literal in generic type + infers type from argument restriction infers type from argument restriction + doesn't infer unbound generic type on generic method called from generic's subclass doesn't infer unbound generic type on generic method called from generic's subclass + infers from method in generic type, with type annotation infers from method in generic type, with type annotation + declares instance var of generic type, with tuple declares instance var of generic type, with tuple infers from Pointer.malloc in generic type infers from Pointer.malloc in generic type + infers type from path that is a constant infers type from path that is a constant + infers from generic class method that has type annotation, without instantiating infers from generic class method that has type annotation, without instantiating declares instance var multiple times, last one wins declares instance var multiple times, last one wins - doesn't infer unbound generic type on generic method called from generic's subclass, metaclass context doesn't infer unbound generic type on generic method called from generic's subclass, metaclass context - infers type from self as virtual type (#2575) infers type from self as virtual type (#2575) - declares instance var of generic type through module declares instance var of generic type through module - errors if unknown ivar through macro (#4050) errors if unknown ivar through macro (#4050) - doesn't error when using Class but specifying type doesn't error when using Class but specifying type - errors on undefined instance var and subclass calling super errors on undefined instance var and subclass calling super - obeys super module initialize (#456) obeys super module initialize (#456) - is more permissive with macro def initialize, other initialize is more permissive with macro def initialize, other initialize - doesn't error if not initializing nilable var in subclass doesn't error if not initializing nilable var in subclass - infers type from uninitialized infers type from uninitialized - declares instance var of generic module (2) declares instance var of generic module (2) - can guess the type from splat argument with splatted type can guess the type from splat argument with splatted type - doesn't crash on missing var on subclass, with superclass not specifying a type doesn't crash on missing var on subclass, with superclass not specifying a type - infers type from hash literal with of infers type from hash literal with of - doesn't error if inheriting generic instance (#3635) doesn't error if inheriting generic instance (#3635) - errors when assigning instance variable at top level control block errors when assigning instance variable at top level control block - errors if declaring instance var and turns out to be nilable, in generic module type in generic type errors if declaring instance var and turns out to be nilable, in generic module type in generic type - infers from Pointer.malloc with two arguments in generic type infers from Pointer.malloc with two arguments in generic type - errors if declaring var in Object errors if declaring var in Object - infers from class method that has number literal infers from class method that has number literal + declares instance var of generic type, with virtual metaclass declares instance var of generic type, with virtual metaclass + infers type from is_a? infers type from is_a? infers from class method that invokes new infers from class method that invokes new - declares instance var in module, inherits to type declares instance var in module, inherits to type - infers type from custom generic hash literal infers type from custom generic hash literal - doesn't crash on recursive method call doesn't crash on recursive method call - errors if declaring var in Class errors if declaring var in Class + infers type from string literal infers type from string literal + doesn't crash on missing var on subclass, with superclass not specifying a type doesn't crash on missing var on subclass, with superclass not specifying a type + errors if not initialized in all initialize errors if not initialized in all initialize + declares instance var of generic type, with no type parameter declares instance var of generic type, with no type parameter + says can't infer type if only nil was assigned says can't infer type if only nil was assigned errors if declaring variable with number errors if declaring variable with number - infers type for generic module infers type for generic module - says undefined instance variable on assign says undefined instance variable on assign - infers from Pointer.malloc with two arguments infers from Pointer.malloc with two arguments - errors if can't find lib call, before erroring on instance var (#2579) errors if can't find lib call, before erroring on instance var (#2579) - infers type from included module recursively infers type from included module recursively + infers type from string interpolation infers type from string interpolation + doesn't infer from class method with multiple statements and return, on non-easy return doesn't infer from class method with multiple statements and return, on non-easy return + ignores super module initialize (#456) ignores super module initialize (#456) + infers type from assign (1) infers type from assign (1) + doesn't error if calling initialize from another initialize (1) doesn't error if calling initialize from another initialize (1) + declares instance var of generic type, with static array declares instance var of generic type, with static array + infers type from self as virtual type (#2575) infers type from self as virtual type (#2575) + errors when assigning instance variable at top level block errors when assigning instance variable at top level block + infers nilable instance var of generic type infers nilable instance var of generic type + declares instance var of generic type, with splat declares instance var of generic type, with splat + declares instance var of generic type, with splat inside Proc declares instance var of generic type, with splat inside Proc + can guess the type from double-splat argument with double-splatted type variable can guess the type from double-splat argument with double-splatted type variable + declares instance var of generic type subclass declares instance var of generic type subclass + doesn't error if not initializing variables but calling previous_def (#3210) doesn't error if not initializing variables but calling previous_def (#3210) + infers type from lib fun call infers type from lib fun call + infers type from enum member infers type from enum member + says undefined instance variable on read says undefined instance variable on read + infers type from ||= inside another assignment infers type from ||= inside another assignment + declares instance var of generic type, with generic type declares instance var of generic type, with generic type + infers type from new expression infers type from new expression + infers type to be non-nilable if initialized in all initialize infers type to be non-nilable if initialized in all initialize + errors when redeclaring subclass variable with a different type errors when redeclaring subclass variable with a different type + is more permissive with macro def initialize is more permissive with macro def initialize + uses virtual types in union uses virtual types in union + uses virtual types in self uses virtual types in self + doesn't error if not initializes in all initialize because declared as nilable doesn't error if not initializes in all initialize because declared as nilable + can't infer type of generic method that returns self (#5383) can't infer type of generic method that returns self (#5383) infers type from range literal infers type from range literal - uses T.new (#4291) uses T.new (#4291) + errors if declaring var in Union(*T) errors if declaring var in Union(*T) + infers type from all call matches infers type from all call matches + doesn't error if not initializing variables but calling super for generic module doesn't error if not initializing variables but calling super for generic module + accepts overriding inherited instance variable with compatible type accepts overriding inherited instance variable with compatible type + errors if declaring var in Object errors if declaring var in Object + doesn't error if initializing var in superclass, and then empty initialize doesn't error if initializing var in superclass, and then empty initialize + errors if declaring var in Tuple(*T) errors if declaring var in Tuple(*T) + infers from Pointer.null infers from Pointer.null + errors if can't find lib call, before erroring on instance var (#2579) errors if can't find lib call, before erroring on instance var (#2579) + allow usage of instance variable initializer from instance variable initializer allow usage of instance variable initializer from instance variable initializer + can't infer type when using operation on const (#4054) can't infer type when using operation on const (#4054) + infers type from if infers type from if + infers type from argument with restriction, in generic infers type from argument with restriction, in generic infers type from proc literal with return type infers type from proc literal with return type - declares as named tuple declares as named tuple - uses virtual types in self uses virtual types in self - infer from class method where new is redefined infer from class method where new is redefined - doesn't find T in generic type that's not the current type (#4460) doesn't find T in generic type that's not the current type (#4460) - infers type from included module infers type from included module - infers type from offsetof infers type from offsetof - infers type from redefined method if calls previous_def infers type from redefined method if calls previous_def - declares instance var of generic module from non-generic module declares instance var of generic module from non-generic module - doesn't solve instance var initializer in instance context (3) (#5876) doesn't solve instance var initializer in instance context (3) (#5876) - errors if declaring instance var and turns out to be nilable, in generic type errors if declaring instance var and turns out to be nilable, in generic type - infers from restriction using virtual type infers from restriction using virtual type - errors if declaring instance var and turns out to be nilable, in generic module type errors if declaring instance var and turns out to be nilable, in generic module type - infers type from argument restriction infers type from argument restriction - infers type from regex literal infers type from regex literal infers from another instance var in generic type infers from another instance var in generic type - errors when assigning instance variable inside nested expression errors when assigning instance variable inside nested expression - can't infer type when using operation on const (#4054) can't infer type when using operation on const (#4054) - errors if declaring var in NamedTuple(T) errors if declaring var in NamedTuple(T) - declares instance var with union type with a virtual member declares instance var with union type with a virtual member - transfers initializer from generic module to class transfers initializer from generic module to class - infers from class method that refers to constant infers from class method that refers to constant - infers type from self (#2575) infers type from self (#2575) - guesses from hash literal with of, with subclass guesses from hash literal with of, with subclass - errors if declaring var in Pointer(T) errors if declaring var in Pointer(T) - infers type from sizeof infers type from sizeof + cannot guess type from argument assigned in body cannot guess type from argument assigned in body + errors on undefined constant errors on undefined constant + doesn't error if not initialized in macro def but outside it doesn't error if not initialized in macro def but outside it + can guess the type from splat argument with splatted type can guess the type from splat argument with splatted type + infers type from literal outside def with initialize and type restriction infers type from literal outside def with initialize and type restriction + infers from new with return type in generic type infers from new with return type in generic type + infers from Pointer.malloc with two arguments in generic type infers from Pointer.malloc with two arguments in generic type + doesn't error if declaring instance var and doesn't out to be nilable, in generic module type doesn't error if declaring instance var and doesn't out to be nilable, in generic module type + can declare type even if included module has a guessed var can declare type even if included module has a guessed var + infers from class method that has type annotation, in generic class infers from class method that has type annotation, in generic class + infers type to be nilable if not initialized infers type to be nilable if not initialized + guesses from as.(typeof(...)) in generic type guesses from as.(typeof(...)) in generic type looks up self restriction in instantiated type, not defined type looks up self restriction in instantiated type, not defined type - says undefined instance variable on read says undefined instance variable on read - infers type from bool literal infers type from bool literal - guesses virtual array type (1) (#5342) guesses virtual array type (1) (#5342) - infers type from char literal infers type from char literal - declares instance var of generic type, with splat inside Proc declares instance var of generic type, with splat inside Proc - declares instance var of generic type, with splat inside Tuple declares instance var of generic type, with splat inside Tuple - infers type from responds_to? infers type from responds_to? - infers type from tuple literal infers type from tuple literal - guesses inside macro for guesses inside macro for - infers type from literal outside def infers type from literal outside def - infers type from unless infers type from unless - declares with `self` declares with `self` - is more permissive with macro def initialize, bug with named args is more permissive with macro def initialize, bug with named args - declares instance var of generic type, with union declares instance var of generic type, with union - doesn't infer type to be nilable if using self.class in call in assign doesn't infer type to be nilable if using self.class in call in assign - infers type from block argument without restriction infers type from block argument without restriction + infers type from case infers type from case + guesses from splat (#3149) guesses from splat (#3149) + infers from method on integer literal, with type annotation infers from method on integer literal, with type annotation + doesn't error if inheriting generic instance (#3635) doesn't error if inheriting generic instance (#3635) + infers type from uninitialized infers type from uninitialized + says undefined instance variable on assign says undefined instance variable on assign + errors when assigning instance variable at top level control block errors when assigning instance variable at top level control block + doesn't find T in generic type that's not the current type (#4460) doesn't find T in generic type that's not the current type (#4460) + doesn't infer type from redefined method doesn't infer type from redefined method + instance variable inherited from multiple parents + with incompatible type + module and class, with definitions module and class, with definitions + errors module and module, with definitions errors module and module, with definitions + errors module and module, with declarations errors module and module, with declarations + module and class, with declarations module and class, with declarations + with compatible type + module and class, with definitions module and class, with definitions + accepts module and module, with declarations accepts module and module, with declarations + module and class, with declarations (3) module and class, with declarations (3) + module and class, with declarations (2) module and class, with declarations (2) + accepts module and module, with definitions accepts module and module, with definitions + module and class, with declarations module and class, with declarations + doesn't error if not initializing variables but calling super and previous_def doesn't error if not initializing variables but calling super and previous_def + can't infer type from initializer in generic class type can't infer type from initializer in generic class type + infers type from custom array literal in generic infers type from custom array literal in generic + ignores redefined initialize (#456) ignores redefined initialize (#456) + infers type from instance_sizeof infers type from instance_sizeof + infers from another instance var in generic type with type declaration infers from another instance var in generic type with type declaration + infers type from array literal with of metaclass infers type from array literal with of metaclass + infers type from array literal with of infers type from array literal with of + infers from assign to local var (#2467) infers from assign to local var (#2467) + infers in multiple assign for tuple type (1) infers in multiple assign for tuple type (1) declares instance var of generic type, with proc declares instance var of generic type, with proc - doesn't consider var as nilable if conditionally assigned inside initialize, but has initializer (#3669) doesn't consider var as nilable if conditionally assigned inside initialize, but has initializer (#3669) + considers var as assigned in multi-assign considers var as assigned in multi-assign + shouldn't error when accessing instance var in initialized that's always initialized (#2953) shouldn't error when accessing instance var in initialized that's always initialized (#2953) + infers from Pointer.null in generic type infers from Pointer.null in generic type + infers type from included module infers type from included module transfers initializer from module to generic class transfers initializer from module to generic class - infers type from || infers type from || - doesn't complain if declared type is recursive alias that's nilable doesn't complain if declared type is recursive alias that's nilable - guesses from splat (#3149) guesses from splat (#3149) - infers type from block argument infers type from block argument - errors if declaring var in Tuple(*T) errors if declaring var in Tuple(*T) -Codegen: const - declaring var declaring var declaring var declaring var declaring var declaring var declaring var declaring var declaring var declaring var - codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name codegens two consts with same variable name - initializes simple const via another const initializes simple const via another const - synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants synchronizes initialization of constants - codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct codegens constant that refers to another constant that is a struct - inlines const with math inlines const with math - define a constant define a constant - uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup uses correct types lookup - initializes simple const initializes simple const - support nested constant support nested constant - allows constants with same name allows constants with same name - allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) allows implicit self in constant, called from another class (bug) - works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if works with variable declared inside if - gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class gets pointerof constant inside class - uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module uses const before declaring it in another module - gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant gets pointerof complex constant - gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant gets pointerof constant - uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) uses const before declaring it (hoisting) - finds global constant finds global constant - constants with expression constants with expression - codegens constant that is declared later because of virtual dispatch codegens constant that is declared later because of virtual dispatch - supports closured vars inside initializers (#10474) supports closured vars inside initializers (#10474) - codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const codegens variable assignment in const - invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const invokes block in const - inlines char const inlines char const - inlines enum value inlines enum value - finds nearest constant first finds nearest constant first - support constant inside a def support constant inside a def - doesn't crash if constant is used, but class is never instantiated (#1106) doesn't crash if constant is used, but class is never instantiated (#1106) - supports storing function returning nil supports storing function returning nil - inlines const referencing another const inlines const referencing another const - inlines bool const inlines bool const - initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception initialize const that might raise an exception - declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order declare constants in right order - inlines simple const inlines simple const - define a constant in lib define a constant in lib - initializes ARGC_UNSAFE initializes ARGC_UNSAFE - runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) runs const side effects (#8862) -Code gen: magic constants - does __FILE__ does __FILE__ - does __LINE__ does __LINE__ - does __END_LINE__ in macro with block does __END_LINE__ in macro with block - does __END_LINE__ without block does __END_LINE__ without block - does __LINE__ in macro does __LINE__ in macro - does __FILE__ in macro does __FILE__ in macro - does __DIR__ in macro does __DIR__ in macro - does __DIR__ does __DIR__ - does __LINE__ when specifying one middle argument does __LINE__ when specifying one middle argument - does __LINE__ when specifying one normal default arg does __LINE__ when specifying one normal default arg - does __LINE__ when specifying one default arg with __FILE__ does __LINE__ when specifying one default arg with __FILE__ - does __LINE__ with dispatch does __LINE__ with dispatch - does __END_LINE__ with block does __END_LINE__ with block - does __END_LINE__ in macro without block does __END_LINE__ in macro without block -View#module_name - namespace is divided by hyphen namespace is divided by hyphen - hyphen followed by non-ascii letter is replaced by its character hyphen followed by non-ascii letter is replaced by its character - underscore is ignored underscore is ignored -Code gen: return - return from function with nilable type 2 return from function with nilable type 2 - returns empty from function returns empty from function - return from function with union type return from function with union type - doesn't crash when method returns nil and can be inlined doesn't crash when method returns nil and can be inlined - codegens assign with if with two returns codegens assign with if with two returns - codegens return codegens return - codegens bug with return if true codegens bug with return if true - codegens return inside if codegens return inside if - return union return union - codegens return followed by another expression codegens return followed by another expression - return from function with nilable type return from function with nilable type - forms a tuple from multiple return values forms a tuple from multiple return values - returns in var assignment (#3364) returns in var assignment (#3364) - flattens splats inside multiple return values flattens splats inside multiple return values -Semantic: ssa - types a var that is declared in a while types a var that is declared in a while - types block with next types block with next - types a var inside an if without previous definition types a var inside an if without previous definition - types a var after begin ensure as having last type types a var after begin ensure as having last type - preserves type filters after block (bug) preserves type filters after block (bug) - types while with next types while with next - types a var that is re-assigned in a block types a var that is re-assigned in a block - types if with restricted type in else types if with restricted type in else - doesn't change type to nilable inside if doesn't change type to nilable inside if - types a var inside an if without change in then types a var inside an if without change in then - types a var that is re-assigned in a while condition types a var that is re-assigned in a while condition - types if with return in then with assign types if with return in then with assign - types a var that is re-assigned in a while in next and used in condition types a var that is re-assigned in a while in next and used in condition - types a var inside an if without definition in else types a var inside an if without definition in else - types block with break types block with break - types a var with an if but without change types a var with an if but without change - types block with break doesn't infect initial vars types block with break doesn't infect initial vars - types if with restricted type in then types if with restricted type in then - types a var that is declared in a while condition types a var that is declared in a while condition - types a var that is declared in a while condition with break after re-assignment types a var that is declared in a while condition with break after re-assignment - types a var that is declared in a while condition with break before re-assignment types a var that is declared in a while condition with break before re-assignment - doesn't error if same variable is used in multiple arguments of same typeof doesn't error if same variable is used in multiple arguments of same typeof - types if/else with var (bug) types if/else with var (bug) - types if with return in then types if with return in then - types if with return in else types if with return in else - types re-assign inside while (bug) types re-assign inside while (bug) - types a var inside an if with previous definition types a var inside an if with previous definition - types re-assign inside if (bug) types re-assign inside if (bug) - types a var after begin ensure as having last type (2) types a var after begin ensure as having last type (2) - errors if accessing variable declared inside typeof errors if accessing variable declared inside typeof - types a var that is re-assigned in a while and used in condition types a var that is re-assigned in a while and used in condition - doesn't error if same variable is declared in multiple typeofs doesn't error if same variable is declared in multiple typeofs - types a var inside an if without definition in then types a var inside an if without definition in then - types a var inside an if without change in else types a var inside an if without change in else - types if with break in then types if with break in then - types if with unreachable in then types if with unreachable in then - types if with return in both branches types if with return in both branches - types a var that is declared in a while with out types a var that is declared in a while with out - types while with break with new var types while with break with new var - types if with next in then types if with next in then - types if with return in else with assign types if with return in else with assign - types while with break types while with break - types a var that is re-assigned in a while types a var that is re-assigned in a while - types a var with an if with nested if types a var with an if with nested if - types a redefined variable types a redefined variable - types while with break doesn't infect initial vars types while with break doesn't infect initial vars -Semantic: NoReturn - types with no return even if code follows types with no return even if code follows - computes NoReturn in a lazy way inside if then (#314) (5) computes NoReturn in a lazy way inside if then (#314) (5) - types union of NoReturn and something else types union of NoReturn and something else - computes NoReturn in a lazy way inside if else (#314) (1) computes NoReturn in a lazy way inside if else (#314) (1) - computes NoReturn in a lazy way inside if else (#314) (2) computes NoReturn in a lazy way inside if else (#314) (2) - computes NoReturn in a lazy way inside if then (#314) (1) computes NoReturn in a lazy way inside if then (#314) (1) - computes NoReturn in a lazy way inside if then (#314) (3) computes NoReturn in a lazy way inside if then (#314) (3) - computes NoReturn in a lazy way inside if then (#314) (2) computes NoReturn in a lazy way inside if then (#314) (2) - types union of NoReturns types union of NoReturns - types call to LibC.exit as NoReturn types call to LibC.exit as NoReturn - computes NoReturn in a lazy way inside if else (#314) (5) computes NoReturn in a lazy way inside if else (#314) (5) - types as NoReturn if typeof(exp)'s exp is NoReturn types as NoReturn if typeof(exp)'s exp is NoReturn - assumes if condition's type filters when else is no return assumes if condition's type filters when else is no return - types exception handler as NoReturn if ensure is NoReturn types exception handler as NoReturn if ensure is NoReturn - types raise as NoReturn types raise as NoReturn - computes NoReturn in a lazy way inside if then (#314) (4) computes NoReturn in a lazy way inside if then (#314) (4) - computes NoReturn in a lazy way inside if else (#314) (3) computes NoReturn in a lazy way inside if else (#314) (3) - types as NoReturn even if Nil return type is forced (#3096) types as NoReturn even if Nil return type is forced (#3096) - computes NoReturn in a lazy way inside if else (#314) (4) computes NoReturn in a lazy way inside if else (#314) (4) -.validate_name - dashes dashes - length length - invalid character invalid character - empty empty - underscores underscores - uppercase uppercase - digits digits -Code gen: primitives - allows @[Primitive] on method that has body allows @[Primitive] on method that has body - can invoke binary on primitive typedef (#614) can invoke binary on primitive typedef (#614) - codegens crystal_type_id for class codegens crystal_type_id for class - codegens bool codegens bool - codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 codegens int128 - allows redefining a primitive method allows redefining a primitive method - atomicrmw - codegens atomicrmw with enums codegens atomicrmw with enums - codegens atomicrmw with enums codegens atomicrmw with enums - codegens atomicrmw with symbols codegens atomicrmw with symbols - codegens f32 codegens f32 - doesn't treat `(1 == 1) == true` as `1 == 1 == true` (#328) doesn't treat `(1 == 1) == true` as `1 == 1 == true` (#328) - codegens crystal_type_id with union type codegens crystal_type_id with union type - sums two numbers out of an [] of Number sums two numbers out of an [] of Number - codegens char ord codegens char ord - va_arg - works with C code works with C code works with C code works with C code works with C code works with C code works with C code works with C code works with C code works with C code - uses llvm's va_arg instruction uses llvm's va_arg instruction - codegens string codegens string - allows @[Primitive] on fun declarations allows @[Primitive] on fun declarations - can invoke cast on primitive typedef (#614) can invoke cast on primitive typedef (#614) - gets crystal class instance type id gets crystal class instance type id - codegens f64 codegens f64 - defined method that calls primitive (bug) defined method that calls primitive (bug) - codegens __LINE__ codegens __LINE__ - doesn't optimize away call whose obj is not passed as self (#2226) doesn't optimize away call whose obj is not passed as self (#2226) - codegens pointer of int codegens pointer of int - codegens long codegens long - codegens int codegens int - uses built-in llvm function that returns a tuple uses built-in llvm function that returns a tuple - codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 codegens uint128 - codegens char codegens char - passes issue #328 passes issue #328 - arithmetic primitives - skips bounds checking when to_i produces same type skips bounds checking when to_i produces same type - codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 codegens 1 - 2 - codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 codegens 1.to_i16 - codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 codegens 2 * 3 - codegens 1 &+ 2 codegens 1 &+ 2 - codegens 1.to_i16! codegens 1.to_i16! - codegens 1 &- 2 codegens 1 &- 2 - codegens 16.unsafe_shl 2 codegens 16.unsafe_shl 2 - codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f codegens 1.to_f - codegens 8.unsafe_mod 3 codegens 8.unsafe_mod 3 - codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 codegens 1 + 2 - codegens 1.to_f! codegens 1.to_f! - codegens 2 &* 3 codegens 2 &* 3 - codegens 16.unsafe_shr 2 codegens 16.unsafe_shr 2 - codegens 8.unsafe_div 3 codegens 8.unsafe_div 3 -Normalize: array literal - normalizes non-empty without of normalizes non-empty without of - normalizes non-empty with of, with splat normalizes non-empty with of, with splat - hoists complex element expressions, array-like hoists complex element expressions, array-like - normalizes non-empty with of normalizes non-empty with of - hoists complex element expressions, array-like generic hoists complex element expressions, array-like generic - normalizes non-empty without of, with splat only normalizes non-empty without of, with splat only - normalizes empty with of normalizes empty with of - normalizes non-empty without of, with splat normalizes non-empty without of, with splat - hoists complex element expressions hoists complex element expressions - hoists complex element expressions, with splat hoists complex element expressions, with splat -Code gen: def - uses dispatch call type for phi (#3529) uses dispatch call type for phi (#3529) - uses previous argument in default value (#1062) uses previous argument in default value (#1062) - codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 codegens bug #119 - codegens recursive type with union codegens recursive type with union - codegens call without args codegens call without args - use target def type as return type use target def type as return type use target def type as return type use target def type as return type use target def type as return type use target def type as return type use target def type as return type use target def type as return type use target def type as return type use target def type as return type - allows to change argument values allows to change argument values - codegens with interesting default argument codegens with interesting default argument - codegens return nil when nilable type (2) codegens return nil when nilable type (2) - codegens def which changes type of arg codegens def which changes type of arg - codegens dispatch with single def when discarding unallocated ones (2) codegens dispatch with single def when discarding unallocated ones (2) - looks up matches in super classes and merges them with subclasses looks up matches in super classes and merges them with subclasses - dispatches on virtual type implementing generic module (related to bug #165) dispatches on virtual type implementing generic module (related to bug #165) - codegens union to union assignment of mutable arg (#3691) codegens union to union assignment of mutable arg (#3691) - uses var after external uses var after external - codegens return nil when nilable type (1) codegens return nil when nilable type (1) - fixes #230: include original owner in mangled def fixes #230: include original owner in mangled def - call external function 'putchar' call external function 'putchar' - codegens recursive nasty code codegens recursive nasty code - codegens yield with destructing tuple having unreachable element codegens yield with destructing tuple having unreachable element - codegens empty def codegens empty def - builds infinite recursive function builds infinite recursive function - codegens with and without many default arguments codegens with and without many default arguments - codegens dispatch with nilable reference union type codegens dispatch with nilable reference union type - codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation codegens and doesn't break if obj is int and there's a mutation - doesn't crash on private def as last expression doesn't crash on private def as last expression - unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def unifies all calls to same def - uses self uses self - codegens dispatch on static method codegens dispatch on static method - call functions defined in any order call functions defined in any order - runs empty def runs empty def - codegens dispatch with single def when discarding unallocated ones (1) codegens dispatch with single def when discarding unallocated ones (1) - codegens dispatch without obj, bug 1 codegens dispatch without obj, bug 1 - puts union before single type in matches preferences puts union before single type in matches preferences - codegens call with args codegens call with args - codegens with and without default arguments codegens with and without default arguments - can match N type argument of static array (#1203) can match N type argument of static array (#1203) - codegens with related types codegens with related types - codegens dispatch without obj, bug 1 codegens dispatch without obj, bug 1 -Crystal::Repl::Interpreter - closures - does closure inside block does closure inside block - does closure without args that captures and modifies two local variables does closure without args that captures and modifies two local variables - does closure inside def does closure inside def - sets ivar of self closured struct (#12341) sets ivar of self closured struct (#12341) - does closure without args that captures and modifies one local variable does closure without args that captures and modifies one local variable - closures self in proc literal closures self in proc literal - closures self in proc literal (implicit self) closures self in proc literal (implicit self) - does nested closure inside proc does nested closure inside proc - closures block args after 8 bytes (the closure var) closures block args after 8 bytes (the closure var) - doesn't mix local vars with closured vars doesn't mix local vars with closured vars - does nested closure inside methods and blocks does nested closure inside methods and blocks - closures self and modifies instance var closures self and modifies instance var - passes closured struct instance var as self passes closured struct instance var as self - does closure inside proc does closure inside proc - does closure inside const does closure inside const - does next inside captured block (#12226) does next inside captured block (#12226) - does closure with pointerof local var does closure with pointerof local var - closures def arguments closures def arguments - does closure inside block, capture block arg does closure inside block, capture block arg - closures closured block arg closures closured block arg - does nested closure inside captured blocks does nested closure inside captured blocks - does closure inside proc, capture proc argument does closure inside proc, capture proc argument - does closure with two args that captures and modifies two local variables does closure with two args that captures and modifies two local variables - reads self closured struct (#12341) reads self closured struct (#12341) - closures struct and calls method on it closures struct and calls method on it - does closure inside class variable initializer does closure inside class variable initializer - does closure and accesses it inside block does closure and accesses it inside block - gets ivar of self closured struct (#12341) gets ivar of self closured struct (#12341) -Crystal::Repl::Interpreter - local variables - interprets variable set and get interprets variable set and get - doesn't declare variable with no type doesn't declare variable with no type - interprets uninitialized interprets uninitialized - assigns to underscore assigns to underscore - interprets variable set and get, second local var interprets variable set and get, second local var - interprets at the class level interprets at the class level - interprets variable set and get with operations interprets variable set and get with operations - doesn't discard underscore right hand side doesn't discard underscore right hand side - interprets variable set with type restriction (#13023) interprets variable set with type restriction (#13023) - interprets variable set interprets variable set - interprets local variable declaration (#12229) interprets local variable declaration (#12229) - doesn't declare variable with no type inside method doesn't declare variable with no type inside method - conversion - interprets Float64#to_f32! (negative) interprets Float64#to_f32! (negative) - interprets Int64::MAX#to_i64! interprets Int64::MAX#to_i64! - interprets Float32#to_i8! (positive) interprets Float32#to_i8! (positive) - interprets UInt64::MAX#to_u64! interprets UInt64::MAX#to_u64! - interprets Int16::MIN#to_i16! interprets Int16::MIN#to_i16! - interprets Int16::MIN#to_u16! interprets Int16::MIN#to_u16! - interprets Int32::MAX#to_i32! interprets Int32::MAX#to_i32! - interprets Int16::MIN#to_u64! interprets Int16::MIN#to_u64! - interprets Float32#to_f32! (positive) interprets Float32#to_f32! (positive) - interprets UInt64::MAX#to_f64! interprets UInt64::MAX#to_f64! - discards conversion discards conversion - interprets Float64#to_i! (negative) interprets Float64#to_i! (negative) - interprets UInt8::MAX#to_f64! interprets UInt8::MAX#to_f64! - interprets UInt32::MAX#to_f64! interprets UInt32::MAX#to_f64! - interprets Int64::MIN#to_f32! interprets Int64::MIN#to_f32! - interprets Float32#to_i16! (positive) interprets Float32#to_i16! (positive) - interprets Int64::MAX#to_i16! interprets Int64::MAX#to_i16! - interprets Int8::MIN#to_f64! interprets Int8::MIN#to_f64! - interprets Int8::MAX#to_u16! interprets Int8::MAX#to_u16! - interprets UInt16::MAX#to_u! interprets UInt16::MAX#to_u! - interprets Int8::MAX#to_u32! interprets Int8::MAX#to_u32! - interprets Int8::MAX#to_i64! interprets Int8::MAX#to_i64! - interprets UInt8::MAX#to_i8! interprets UInt8::MAX#to_i8! - interprets Int16::MAX#to_u! interprets Int16::MAX#to_u! - interprets Int16::MAX#to_u16! interprets Int16::MAX#to_u16! - interprets UInt8::MAX#to_u16! interprets UInt8::MAX#to_u16! - interprets Int32::MIN#to_i8! interprets Int32::MIN#to_i8! - interprets Float64#to_i32! (positive) interprets Float64#to_i32! (positive) - interprets UInt16::MAX#to_i! interprets UInt16::MAX#to_i! - interprets UInt16::MAX#to_u32! interprets UInt16::MAX#to_u32! - interprets UInt16::MAX#to_u64! interprets UInt16::MAX#to_u64! - interprets Int32::MIN#to_u8! interprets Int32::MIN#to_u8! - interprets Int32::MIN#to_f64! interprets Int32::MIN#to_f64! - interprets Float64#to_f64! (negative) interprets Float64#to_f64! (negative) - interprets Int8::MAX#to_u8! interprets Int8::MAX#to_u8! - interprets UInt8::MAX#to_u32! interprets UInt8::MAX#to_u32! - interprets UInt8::MAX#to_i! interprets UInt8::MAX#to_i! - interprets UInt32::MAX#to_u! interprets UInt32::MAX#to_u! - interprets Float32#to_i64! (negative) interprets Float32#to_i64! (negative) - interprets Int32::MAX#to_f32! interprets Int32::MAX#to_f32! - interprets UInt64::MAX#to_i16! interprets UInt64::MAX#to_i16! - interprets Int32::MAX#to_i16! interprets Int32::MAX#to_i16! - interprets Int64::MAX#to_i32! interprets Int64::MAX#to_i32! - interprets Float64#to_u32! (positive) interprets Float64#to_u32! (positive) - interprets UInt16::MAX#to_u16! interprets UInt16::MAX#to_u16! - interprets Int16::MAX#to_i16! interprets Int16::MAX#to_i16! - interprets Int64::MIN#to_i16! interprets Int64::MIN#to_i16! - interprets Int64::MIN#to_i! interprets Int64::MIN#to_i! - interprets Int32::MAX#to_f64! interprets Int32::MAX#to_f64! - interprets Int32::MAX#to_u16! interprets Int32::MAX#to_u16! - interprets UInt16::MAX#to_i8! interprets UInt16::MAX#to_i8! - interprets UInt8::MAX#to_i64! interprets UInt8::MAX#to_i64! - interprets UInt64::MAX#to_i8! interprets UInt64::MAX#to_i8! - interprets Int16::MIN#to_i8! interprets Int16::MIN#to_i8! - interprets Int16::MAX#to_u32! interprets Int16::MAX#to_u32! - interprets Int32::MAX#to_u32! interprets Int32::MAX#to_u32! - interprets UInt32::MAX#to_i16! interprets UInt32::MAX#to_i16! - interprets Float32#to_f64! (negative) interprets Float32#to_f64! (negative) - interprets Int64::MIN#to_u64! interprets Int64::MIN#to_u64! - interprets Int16::MIN#to_u32! interprets Int16::MIN#to_u32! - interprets Int64::MIN#to_i64! interprets Int64::MIN#to_i64! - interprets Int8::MIN#to_i32! interprets Int8::MIN#to_i32! - interprets Int16::MAX#to_f64! interprets Int16::MAX#to_f64! - interprets Int32::MIN#to_f32! interprets Int32::MIN#to_f32! - interprets Int8::MIN#to_f32! interprets Int8::MIN#to_f32! - interprets UInt16::MAX#to_i32! interprets UInt16::MAX#to_i32! - interprets Int64::MAX#to_f32! interprets Int64::MAX#to_f32! - interprets Float32#to_u! (positive) interprets Float32#to_u! (positive) - interprets UInt16::MAX#to_u8! interprets UInt16::MAX#to_u8! - interprets Int8::MIN#to_i! interprets Int8::MIN#to_i! - interprets UInt8::MAX#to_f32! interprets UInt8::MAX#to_f32! - interprets Float64#to_f32! (positive) interprets Float64#to_f32! (positive) - interprets Int8::MIN#to_u16! interprets Int8::MIN#to_u16! - interprets Int8::MAX#to_i8! interprets Int8::MAX#to_i8! - interprets Int32::MIN#to_i! interprets Int32::MIN#to_i! - interprets Int64::MIN#to_u32! interprets Int64::MIN#to_u32! - interprets UInt32::MAX#to_u8! interprets UInt32::MAX#to_u8! - interprets UInt32::MAX#to_u16! interprets UInt32::MAX#to_u16! - interprets Int16::MIN#to_u8! interprets Int16::MIN#to_u8! - interprets Int64::MAX#to_f64! interprets Int64::MAX#to_f64! - interprets Int8::MAX#to_i32! interprets Int8::MAX#to_i32! - discards conversion with local var discards conversion with local var - interprets Int8::MAX#to_i16! interprets Int8::MAX#to_i16! - interprets Int8::MAX#to_f32! interprets Int8::MAX#to_f32! - interprets UInt32::MAX#to_u64! interprets UInt32::MAX#to_u64! - interprets Int32::MIN#to_i16! interprets Int32::MIN#to_i16! - interprets Float32#to_u16! (positive) interprets Float32#to_u16! (positive) - interprets Int64::MIN#to_i32! interprets Int64::MIN#to_i32! - interprets Int32::MIN#to_u16! interprets Int32::MIN#to_u16! - interprets Int16::MAX#to_u64! interprets Int16::MAX#to_u64! - interprets Float32#to_i32! (positive) interprets Float32#to_i32! (positive) - interprets Int32::MAX#to_u64! interprets Int32::MAX#to_u64! - interprets UInt8::MAX#to_i32! interprets UInt8::MAX#to_i32! - interprets Float64#to_u64! (positive) interprets Float64#to_u64! (positive) - UInt8#unsafe_chr UInt8#unsafe_chr - interprets Int16::MAX#to_i32! interprets Int16::MAX#to_i32! - interprets Float32#to_i32! (negative) interprets Float32#to_i32! (negative) - interprets Int64::MAX#to_i8! interprets Int64::MAX#to_i8! - interprets Int64::MIN#to_u! interprets Int64::MIN#to_u! - interprets Int16::MIN#to_i64! interprets Int16::MIN#to_i64! - interprets Int64::MAX#to_u! interprets Int64::MAX#to_u! - interprets Float32#to_u64! (positive) interprets Float32#to_u64! (positive) - interprets Float32#to_i8! (negative) interprets Float32#to_i8! (negative) - interprets UInt64::MAX#to_u16! interprets UInt64::MAX#to_u16! - interprets UInt32::MAX#to_i64! interprets UInt32::MAX#to_i64! - interprets Int16::MAX#to_i8! interprets Int16::MAX#to_i8! - interprets UInt64::MAX#to_i64! interprets UInt64::MAX#to_i64! - interprets Int16::MAX#to_f32! interprets Int16::MAX#to_f32! - interprets Char#ord interprets Char#ord - interprets Int16::MAX#to_i! interprets Int16::MAX#to_i! - interprets Float32#to_f64! (positive) interprets Float32#to_f64! (positive) - interprets Int64::MAX#to_u8! interprets Int64::MAX#to_u8! - interprets Float64#to_i! (positive) interprets Float64#to_i! (positive) - interprets Int16::MIN#to_i32! interprets Int16::MIN#to_i32! - interprets UInt8::MAX#to_i16! interprets UInt8::MAX#to_i16! - interprets Int8::MIN#to_i64! interprets Int8::MIN#to_i64! - interprets Int16::MAX#to_i64! interprets Int16::MAX#to_i64! - interprets Int16::MIN#to_f32! interprets Int16::MIN#to_f32! - interprets Int64::MIN#to_u16! interprets Int64::MIN#to_u16! - interprets UInt64::MAX#to_i! interprets UInt64::MAX#to_i! - interprets UInt32::MAX#to_f32! interprets UInt32::MAX#to_f32! - interprets Int32::MAX#to_u! interprets Int32::MAX#to_u! - interprets Float32#to_i! (negative) interprets Float32#to_i! (negative) - interprets Int16::MIN#to_f64! interprets Int16::MIN#to_f64! - interprets UInt64::MAX#to_u32! interprets UInt64::MAX#to_u32! - interprets Float64#to_i8! (negative) interprets Float64#to_i8! (negative) - interprets UInt16::MAX#to_f32! interprets UInt16::MAX#to_f32! - interprets UInt16::MAX#to_f64! interprets UInt16::MAX#to_f64! - interprets UInt32::MAX#to_i32! interprets UInt32::MAX#to_i32! - interprets Int16::MAX#to_u8! interprets Int16::MAX#to_u8! - interprets Float64#to_i32! (negative) interprets Float64#to_i32! (negative) - interprets Float64#to_u8! (positive) interprets Float64#to_u8! (positive) - interprets Int8::MIN#to_u! interprets Int8::MIN#to_u! - interprets Float64#to_i8! (positive) interprets Float64#to_i8! (positive) - interprets UInt16::MAX#to_i64! interprets UInt16::MAX#to_i64! - interprets Int64::MAX#to_u64! interprets Int64::MAX#to_u64! - interprets UInt32::MAX#to_u32! interprets UInt32::MAX#to_u32! - interprets Int64::MAX#to_u16! interprets Int64::MAX#to_u16! - interprets Float32#to_u8! (positive) interprets Float32#to_u8! (positive) - interprets UInt32::MAX#to_i! interprets UInt32::MAX#to_i! - interprets Int8::MIN#to_u8! interprets Int8::MIN#to_u8! - interprets Int64::MAX#to_u32! interprets Int64::MAX#to_u32! - interprets Float32#to_i! (positive) interprets Float32#to_i! (positive) - interprets UInt32::MAX#to_i8! interprets UInt32::MAX#to_i8! - interprets UInt64::MAX#to_u! interprets UInt64::MAX#to_u! - interprets Float32#to_u32! (positive) interprets Float32#to_u32! (positive) - interprets Int32::MIN#to_u32! interprets Int32::MIN#to_u32! - interprets Int16::MIN#to_i! interprets Int16::MIN#to_i! - interprets Int32::MIN#to_u! interprets Int32::MIN#to_u! - interprets UInt8::MAX#to_u! interprets UInt8::MAX#to_u! - interprets UInt16::MAX#to_i16! interprets UInt16::MAX#to_i16! - interprets Int64::MIN#to_f64! interprets Int64::MIN#to_f64! - interprets Int8::MIN#to_u64! interprets Int8::MIN#to_u64! - interprets UInt8::MAX#to_u8! interprets UInt8::MAX#to_u8! - interprets Float32#to_i16! (negative) interprets Float32#to_i16! (negative) - interprets Int32::MIN#to_i64! interprets Int32::MIN#to_i64! - interprets Int32::MAX#to_i64! interprets Int32::MAX#to_i64! - interprets Float64#to_i64! (positive) interprets Float64#to_i64! (positive) - interprets Float64#to_u! (positive) interprets Float64#to_u! (positive) - interprets Int32::MAX#to_u8! interprets Int32::MAX#to_u8! - interprets Int8::MIN#to_u32! interprets Int8::MIN#to_u32! - interprets UInt8::MAX#to_u64! interprets UInt8::MAX#to_u64! - interprets Int64::MAX#to_i! interprets Int64::MAX#to_i! - interprets Int8::MAX#to_u! interprets Int8::MAX#to_u! - interprets UInt64::MAX#to_i32! interprets UInt64::MAX#to_i32! - interprets Float64#to_i16! (positive) interprets Float64#to_i16! (positive) - interprets Float32#to_i64! (positive) interprets Float32#to_i64! (positive) - Int32#unsafe_chr Int32#unsafe_chr - interprets Int8::MIN#to_i16! interprets Int8::MIN#to_i16! - interprets UInt64::MAX#to_f32! interprets UInt64::MAX#to_f32! - interprets Int64::MIN#to_i8! interprets Int64::MIN#to_i8! - interprets Int8::MIN#to_i8! interprets Int8::MIN#to_i8! - interprets Int32::MIN#to_i32! interprets Int32::MIN#to_i32! - interprets Int64::MIN#to_u8! interprets Int64::MIN#to_u8! - interprets Int32::MAX#to_i! interprets Int32::MAX#to_i! - interprets Int32::MAX#to_i8! interprets Int32::MAX#to_i8! - interprets Float64#to_u16! (positive) interprets Float64#to_u16! (positive) - interprets Int16::MIN#to_u! interprets Int16::MIN#to_u! - interprets Int8::MAX#to_u64! interprets Int8::MAX#to_u64! - interprets Int8::MAX#to_i! interprets Int8::MAX#to_i! - interprets Float64#to_i64! (negative) interprets Float64#to_i64! (negative) - interprets Float64#to_i16! (negative) interprets Float64#to_i16! (negative) - interprets Int8::MAX#to_f64! interprets Int8::MAX#to_f64! - interprets Float32#to_f32! (negative) interprets Float32#to_f32! (negative) - interprets Int32::MIN#to_u64! interprets Int32::MIN#to_u64! - interprets Float64#to_f64! (positive) interprets Float64#to_f64! (positive) - interprets UInt64::MAX#to_u8! interprets UInt64::MAX#to_u8! - math - interprets Int32 * Int32 interprets Int32 * Int32 - discards math discards math - interprets UInt64 * Int32 interprets UInt64 * Int32 - interprets UInt32 - Int32 interprets UInt32 - Int32 - interprets Float64 + Int32 interprets Float64 + Int32 - interprets UInt64 & Int32 interprets UInt64 & Int32 - interprets Float32 + Float64 interprets Float32 + Float64 - interprets Int32 &- Int32 interprets Int32 &- Int32 - interprets Int32 &+ Int32 interprets Int32 &+ Int32 - interprets Int32 + Float64 interprets Int32 + Float64 - interprets UInt64 | UInt32 interprets UInt64 | UInt32 - interprets Int8 + Int8 interprets Int8 + Int8 - interprets Int32 &* Int32 interprets Int32 &* Int32 - interprets Float64 - Float64 interprets Float64 - Float64 - interprets Int32 - Int32 interprets Int32 - Int32 - interprets UInt8 | Int32 interprets UInt8 | Int32 - interprets Float64 * Float64 interprets Float64 * Float64 - interprets Int128 + Int32 interprets Int128 + Int32 - interprets Int32.unsafe_shl(Int32) with self interprets Int32.unsafe_shl(Int32) with self - interprets Int64 + Int64 interprets Int64 + Int64 - interprets Float64 + Float64 interprets Float64 + Float64 - interprets Int32 + Int32 interprets Int32 + Int32 - logical operations - discards bool not discards bool not - interprets not for nilable proc type (false) interprets not for nilable proc type (false) - interprets not for bool false interprets not for bool false - interprets not for generic module metaclass interprets not for generic module metaclass - discards nil not discards nil not - interprets not for bool true interprets not for bool true - interprets not for nilable type (false) interprets not for nilable type (false) - does math primitive on union does math primitive on union - interprets not for generic class instance type interprets not for generic class instance type - interprets not for generic class instance metaclass interprets not for generic class instance metaclass - interprets not for nilable type (true) interprets not for nilable type (true) - interprets not for mixed union (true) interprets not for mixed union (true) - interprets not for nilable type (false) interprets not for nilable type (false) - interprets not for mixed union (nil) interprets not for mixed union (nil) - interprets not for nil interprets not for nil - interprets not for nilable proc type (true) interprets not for nilable proc type (true) - interprets not for generic module interprets not for generic module - does math convert on union does math convert on union - interprets not for module (#12918) interprets not for module (#12918) - interprets not for mixed union (other) interprets not for mixed union (other) - interprets not for nil type interprets not for nil type - interprets not for nilable type (true) interprets not for nilable type (true) - interprets not for bool false interprets not for bool false - interprets not for mixed union (false) interprets not for mixed union (false) - overflow - conversion - overlows on -1_i64.to_u8 overlows on -1_i64.to_u8 - overlows on -1_i16.to_u32 overlows on -1_i16.to_u32 - overlows on 65536_f32.to_u16 overlows on 65536_f32.to_u16 - overlows on -1.to_u8 overlows on -1.to_u8 - overlows on 128_f64.to_i8 overlows on 128_f64.to_i8 - overlows on 256_f64.to_u8 overlows on 256_f64.to_u8 - overlows on 32768_u32.to_i16 overlows on 32768_u32.to_i16 - overlows on 32768_u16.to_i16 overlows on 32768_u16.to_i16 - overlows on 4294967296_f64.to_u32 overlows on 4294967296_f64.to_u32 - overlows on -1.to_u32 overlows on -1.to_u32 - overlows on 128_u64.to_i8 overlows on 128_u64.to_i8 - overlows on 128_u16.to_i8 overlows on 128_u16.to_i8 - overlows on -1_i8.to_u64 overlows on -1_i8.to_u64 - overlows on 1.7976931348623157e+308.to_f32 overlows on 1.7976931348623157e+308.to_f32 - overlows on 2147483648_f64.to_i32 overlows on 2147483648_f64.to_i32 - overlows on 128_f32.to_i8 overlows on 128_f32.to_i8 - overlows on -1_i64.to_u64 overlows on -1_i64.to_u64 - overlows on -1.to_u16 overlows on -1.to_u16 - overlows on 2147483648_u32.to_i32 overlows on 2147483648_u32.to_i32 - overlows on -1_i16.to_u64 overlows on -1_i16.to_u64 - overlows on -1_i16.to_u8 overlows on -1_i16.to_u8 - overlows on 256_f32.to_u8 overlows on 256_f32.to_u8 - overlows on -1_i64.to_u16 overlows on -1_i64.to_u16 - overlows on -1_i16.to_u16 overlows on -1_i16.to_u16 - overlows on -1_i8.to_u16 overlows on -1_i8.to_u16 - overlows on -1_i8.to_u8 overlows on -1_i8.to_u8 - overlows on 32768_f64.to_i16 overlows on 32768_f64.to_i16 - overlows on -1_i64.to_u32 overlows on -1_i64.to_u32 - overlows on -1.to_u64 overlows on -1.to_u64 - overlows on 9223372036854775808_u64.to_i64 overlows on 9223372036854775808_u64.to_i64 - overlows on 128_u8.to_i8 overlows on 128_u8.to_i8 - overlows on 128_u32.to_i8 overlows on 128_u32.to_i8 - overlows on -1_i8.to_u32 overlows on -1_i8.to_u32 - overlows on 2147483648_u64.to_i32 overlows on 2147483648_u64.to_i32 - overlows on 65536_f64.to_u16 overlows on 65536_f64.to_u16 - overlows on 32768_f32.to_i16 overlows on 32768_f32.to_i16 - overlows on 32768_u64.to_i16 overlows on 32768_u64.to_i16 - * - overlows on 20_u64 * 1844674407370955161_i64 overlows on 20_u64 * 1844674407370955161_i64 - overlows on 10_i8 * 14 overlows on 10_i8 * 14 - overlows on 20_u32 * 429496729 overlows on 20_u32 * 429496729 - overlows on 10_u8 * 26 overlows on 10_u8 * 26 - overlows on 10_i16 * 3300 overlows on 10_i16 * 3300 - overlows on 10_u16 * 6600 overlows on 10_u16 * 6600 - overlows on 20 * 214748364 overlows on 20 * 214748364 - overlows on 20_i64 * 922337203685477580_i64 overlows on 20_i64 * 922337203685477580_i64 - + - overlows on 1_i16 + 32767 overlows on 1_i16 + 32767 - overlows on 1 + 2147483647 overlows on 1 + 2147483647 - overlows on 1_u64 + 18446744073709551615_u64 overlows on 1_u64 + 18446744073709551615_u64 - overlows on 1_i64 + 9223372036854775807_i64 overlows on 1_i64 + 9223372036854775807_i64 - overlows on 1_i8 + 128 overlows on 1_i8 + 128 - overlows on 1_u32 + 4294967295_i64 overlows on 1_u32 + 4294967295_i64 - overlows on 1_u16 + 65535 overlows on 1_u16 + 65535 - overlows on 1_u8 + 255 overlows on 1_u8 + 255 - - - overlows on 1_i8 - 256 overlows on 1_i8 - 256 - overlows on 1_i64 - 9223372036854775810_u64 overlows on 1_i64 - 9223372036854775810_u64 - overlows on 1_u64 - 2 overlows on 1_u64 - 2 - overlows on 1_i16 - 32770 overlows on 1_i16 - 32770 - overlows on 1_u16 - 2 overlows on 1_u16 - 2 - overlows on 1_u32 - 2 overlows on 1_u32 - 2 - overlows on 1_u8 - 2 overlows on 1_u8 - 2 - overlows on 1 - 2147483650_i64 overlows on 1 - 2147483650_i64 - comparisons - interprets Int128 == Int128 (true) interprets Int128 == Int128 (true) - interprets UInt64 == Int32 (false when Int32 < 0) interprets UInt64 == Int32 (false when Int32 < 0) - interprets Int32 < Float64 interprets Int32 < Float64 - interprets Float32 fdiv Float64 interprets Float32 fdiv Float64 - interprets Float32 / Float32 interprets Float32 / Float32 - interprets Char == Char (false) interprets Char == Char (false) - interprets Bool != Bool (true) interprets Bool != Bool (true) - discards comparison discards comparison - interprets Float64 / Float64 interprets Float64 / Float64 - interprets UInt32 < Int32 (false) interprets UInt32 < Int32 (false) - interprets UInt64 == Int32 (true when Int32 >= 0) interprets UInt64 == Int32 (true when Int32 >= 0) - interprets UInt64 != Int32 (true) interprets UInt64 != Int32 (true) - interprets Int32 < Int32 interprets Int32 < Int32 - interprets Int32 != UInt64 (true) interprets Int32 != UInt64 (true) - interprets Float64 < Int32 interprets Float64 < Int32 - interprets UInt64 == Int32 (false when Int32 >= 0) interprets UInt64 == Int32 (false when Int32 >= 0) - interprets Int32 == UInt64 (false) interprets Int32 == UInt64 (false) - interprets Float64 < Float64 interprets Float64 < Float64 - interprets Char == Char (true) interprets Char == Char (true) - interprets Float64 fdiv Float32 interprets Float64 fdiv Float32 - interprets Int128 == Int128 (false) interprets Int128 == Int128 (false) - interprets Int32 == Float64 (false) interprets Int32 == Float64 (false) - interprets UInt64 < Int32 (false, right is less than zero) interprets UInt64 < Int32 (false, right is less than zero) - interprets UInt64 < Int32 (false, right is greater than zero) interprets UInt64 < Int32 (false, right is greater than zero) - interprets Int32 != UInt64 (false) interprets Int32 != UInt64 (false) - interprets Float32 / Int32 interprets Float32 / Int32 - interprets Int32 == Int32 (true) interprets Int32 == Int32 (true) - interprets UInt8 < Int32 (false, right is less than zero) interprets UInt8 < Int32 (false, right is less than zero) - interprets Int32 != Int32 (true) interprets Int32 != Int32 (true) - interprets UInt8 < Int32 (true, right is greater than zero) interprets UInt8 < Int32 (true, right is greater than zero) - interprets Int32 > Float64 (true) interprets Int32 > Float64 (true) - interprets UInt32 < Int32 (true) interprets UInt32 < Int32 (true) - interprets UInt64 != Int32 (false) interprets UInt64 != Int32 (false) - interprets UInt64 > UInt32 (false) interprets UInt64 > UInt32 (false) - interprets UInt64 < Int32 (true, right is greater than zero) interprets UInt64 < Int32 (true, right is greater than zero) - interprets Int32 == Int32 (false) interprets Int32 == Int32 (false) - interprets Bool == Bool (true) interprets Bool == Bool (true) - interprets Int32 == UInt64 (true) interprets Int32 == UInt64 (true) - interprets UInt64.unsafe_mod(UInt64) interprets UInt64.unsafe_mod(UInt64) - interprets Bool == Bool (false) interprets Bool == Bool (false) - interprets UInt8 < Int32 (false, right is greater than zero) interprets UInt8 < Int32 (false, right is greater than zero) - interprets Int32 > Float64 (false) interprets Int32 > Float64 (false) - interprets Bool != Bool (false) interprets Bool != Bool (false) - interprets Int32 != Int32 (false) interprets Int32 != Int32 (false) - interprets Int32 == Float64 (true) interprets Int32 == Float64 (true) - interprets UInt64 > UInt32 (true) interprets UInt64 > UInt32 (true) - literals - interprets a bool (false) interprets a bool (false) - interprets an UInt128 interprets an UInt128 - interprets nil interprets nil - interprets an Int8 interprets an Int8 - interprets a char interprets a char - interprets an Int64 interprets an Int64 - interprets an UInt8 interprets an UInt8 - precomputes string literal length precomputes string literal length - interprets an UInt16 interprets an UInt16 - interprets an Int16 interprets an Int16 - interprets an UInt64 interprets an UInt64 - interprets a Float64 interprets a Float64 - interprets a Float32 interprets a Float32 - interprets a bool (true) interprets a bool (true) - interprets an Int128 interprets an Int128 - interprets an Int32 interprets an Int32 - interprets an UInt32 interprets an UInt32 - interprets a String literal interprets a String literal - uses a string pool uses a string pool -Semantic: pointer - doesn't crash if pointerof expansion type has generic splat parameter (#11808) doesn't crash if pointerof expansion type has generic splat parameter (#11808) - types pointer diff types pointer diff - errors with non-matching generic value with value=, union of generic types (#10544) errors with non-matching generic value with value=, union of generic types (#10544) - errors with non-matching generic value with value=, generic type (#10211) errors with non-matching generic value with value=, generic type (#10211) - detects recursive pointerof expansion (3) detects recursive pointerof expansion (3) - errors if doing Pointer.allocate errors if doing Pointer.allocate - pointer of value error pointer of value error - allows using pointer with subclass allows using pointer with subclass - types pointer of constant types pointer of constant - can assign pointerof virtual type (#8216) can assign pointerof virtual type (#8216) - types pointer value types pointer value - can pass any pointer to something expecting void* in lib call, with to_unsafe can pass any pointer to something expecting void* in lib call, with to_unsafe - types realloc types realloc - errors with non-matching generic value with value= (#10211) errors with non-matching generic value with value= (#10211) - type pointer casting type pointer casting - detects recursive pointerof expansion (4) detects recursive pointerof expansion (4) - types pointer add types pointer add - says undefined variable (#7556) says undefined variable (#7556) - type pointer casting of object type type pointer casting of object type - can't do Pointer.malloc without type var can't do Pointer.malloc without type var - types pointer value on typedef types pointer value on typedef - detects recursive pointerof expansion (#551) (#553) detects recursive pointerof expansion (#551) (#553) - pointer malloc creates new type pointer malloc creates new type - types int pointer types int pointer - can pass any pointer to something expecting void* in lib call can pass any pointer to something expecting void* in lib call - takes pointerof lib external var takes pointerof lib external var - pointer of class raises error pointer of class raises error - types Pointer.malloc types Pointer.malloc - detects recursive pointerof expansion (2) (#1654) detects recursive pointerof expansion (2) (#1654) - can assign nil to void pointer can assign nil to void pointer - create pointer by address create pointer by address -Semantic: doc - stores doc for enum with @[Flags] stores doc for enum with @[Flags] - doc before annotation - attached to alias attached to alias - attached to enum attached to enum - attached to macro attached to macro - attached to macro call attached to macro call - attached to macro call that produces multiple types attached to macro call that produces multiple types - attached to constant attached to constant - attached to module attached to module - attached to struct/class attached to struct/class - attached to def attached to def - overwrites doc for struct when reopening overwrites doc for struct when reopening - stores doc for enum when reopening stores doc for enum when reopening - overwrites doc for enum when reopening overwrites doc for enum when reopening - overwrites doc for macro when redefining overwrites doc for macro when redefining - stores doc for def stores doc for def - stores doc for def with annotation stores doc for def with annotation - stores doc for module stores doc for module - stores doc for enum member stores doc for enum member - stores doc for def with visibility stores doc for def with visibility - stores doc for def with annotation stores doc for def with annotation - overwrites doc for module when reopening overwrites doc for module when reopening - stores doc for fun def stores doc for fun def - stores doc for macro defined in macro call stores doc for macro defined in macro call - stores doc for nodes defined in macro call stores doc for nodes defined in macro call - stores doc for flags enum with base type stores doc for flags enum with base type - stores locations for auto-generated module stores locations for auto-generated module - stores doc for macro stores doc for macro - stores doc for struct stores doc for struct - stores doc for abstract def stores doc for abstract def - stores doc for class when reopening stores doc for class when reopening - stores doc for class stores doc for class - stores doc for enum stores doc for enum - overwrites doc for class when reopening overwrites doc for class when reopening - stores doc for alias stores doc for alias - :ditto: - amend previous doc (without empty line) amend previous doc (without empty line) - amend previous doc amend previous doc - stores doc for macro stores doc for macro - stores doc for const stores doc for const - :ditto: references last non-ditto doc :ditto: references last non-ditto doc - stores doc for def stores doc for def - stores location for implicit flag enum members stores location for implicit flag enum members - attaches doc to annotation in macro expansion (#9628) attaches doc to annotation in macro expansion (#9628) - stores doc for abstract class stores doc for abstract class - stores doc for constant stores doc for constant - stores doc for nodes defined in macro call (2) stores doc for nodes defined in macro call (2) - stores doc for enum and doesn't mix with value stores doc for enum and doesn't mix with value - stores doc for struct when reopening stores doc for struct when reopening - overwrites doc for def when redefining overwrites doc for def when redefining - attaches doc in double macro expansion (#8463) attaches doc in double macro expansion (#8463) - stores doc for module when reopening stores doc for module when reopening -Crystal::Repl::Interpreter - instance_sizeof - interprets instance_sizeof typeof interprets instance_sizeof typeof - instance_alignof - interprets instance_alignof typeof interprets instance_alignof typeof - sizeof - interprets sizeof typeof interprets sizeof typeof - alignof - interprets alignof typeof interprets alignof typeof -Semantic: class var + declares instance var of generic type, with metaclass declares instance var of generic type, with metaclass + declares instance var with union type with a virtual member declares instance var with union type with a virtual member + guesses virtual hash type (2) (#5342) guesses virtual hash type (2) (#5342) + infers from assign to local var in generic type (#2467) infers from assign to local var in generic type (#2467) + doesn't if declaring nilable instance var and turns out to be nilable doesn't if declaring nilable instance var and turns out to be nilable + infers type from lib out (2) infers type from lib out (2) + declares instance var of generic type through module declares instance var of generic type through module + guesses virtual array type (2) (#5342) guesses virtual array type (2) (#5342) + guesses from as.(typeof(...)) guesses from as.(typeof(...)) + infers type from included module recursively infers type from included module recursively + uses T.new (#4291) uses T.new (#4291) + doesn't infer generic type without type argument inside generic doesn't infer generic type without type argument inside generic + errors when typing an instance variable inside a method errors when typing an instance variable inside a method + errors if adds instance variable to Object via guess errors if adds instance variable to Object via guess + infers type from as infers type from as infers type from number literal infers type from number literal - declares class variable declares class variable - can find class var through included module can find class var through included module - gives correct error when trying to use Int as a class variable type gives correct error when trying to use Int as a class variable type - redefines class variable type redefines class variable type - errors if class variable not nilable without initializer errors if class variable not nilable without initializer - infers in multiple assign for tuple type (1) infers in multiple assign for tuple type (1) - errors if redefining class var type in subclass, with guess errors if redefining class var type in subclass, with guess - errors when typing a class variable inside a method errors when typing a class variable inside a method - errors if redefining class var type in included module errors if redefining class var type in included module - declares class var in generic class declares class var in generic class - declares class variable (2) declares class variable (2) - errors if using self as type var but there's no self errors if using self as type var but there's no self - says undefined class variable says undefined class variable - infers type from T.new infers type from T.new - errors on undefined constant (1) errors on undefined constant (1) - declares uninitialized (#2935) declares uninitialized (#2935) - errors if using class variable at the top level errors if using class variable at the top level - can assign to class variable if this type can be up-casted to ancestors class variable type (#4869) can assign to class variable if this type can be up-casted to ancestors class variable type (#4869) + infers type for generic class, with begin infers type for generic class, with begin + says can't infer type if only nil was assigned, in generic type says can't infer type if only nil was assigned, in generic type + infers type from named tuple literal infers type from named tuple literal errors when using Class (#2605) errors when using Class (#2605) - allows class var in primitive types (#612) allows class var in primitive types (#612) - doesn't error if accessing class variable before defined (#2941) doesn't error if accessing class variable before defined (#2941) - declares class var in generic module declares class var in generic module - types class var inside instance method types class var inside instance method - can find class var in subclass can find class var in subclass - can access constant from generic metaclass (#3719) can access constant from generic metaclass (#3719) - types class var as nil if assigned for the first time inside method (#2059) types class var as nil if assigned for the first time inside method (#2059) - types as nilable if doesn't have initializer types as nilable if doesn't have initializer - errors on undefined constant (2) errors on undefined constant (2) - doesn't error on recursive dependency if var is nilable (#2943) doesn't error on recursive dependency if var is nilable (#2943) - types class var inside proc literal inside class types class var inside proc literal inside class - errors if redefining class var type in subclass errors if redefining class var type in subclass - allows self.class as type var in class body (#537) allows self.class as type var in class body (#537) - types class var types class var - types class var as nil if not assigned at the top level types class var as nil if not assigned at the top level - errors if using local variable in initializer errors if using local variable in initializer + types generic instance as virtual type if generic type has subclasses (#3805) types generic instance as virtual type if generic type has subclasses (#3805) + errors if not initializing super variable in generic errors if not initializing super variable in generic + doesn't crash on #3580 doesn't crash on #3580 + doesn't error if initializes via super in macro def doesn't error if initializes via super in macro def + errors when assigning instance variable inside nested expression errors when assigning instance variable inside nested expression + guesses inside macro for guesses inside macro for +immutability of returned container literals (#10818) + Annotation#args Annotation#args + When#conds When#conds + Generic#type_vars Generic#type_vars + ProcPointer#args ProcPointer#args + MultiAssign#targets MultiAssign#targets + ProcNotation#inputs ProcNotation#inputs + MultiAssign#values MultiAssign#values + StringInterpolation#expressions StringInterpolation#expressions + Union#types Union#types +Crystal::Playground::Session + assert assert Crystal::Repl::Interpreter enum does enum value does enum value does enum new does enum new -Code gen: def with default value - considers first the one with a restriction considers first the one with a restriction - considers first the one with more arguments considers first the one with more arguments - codegens def new with one default value codegens def new with one default value - resolves expanded call to current type, not to virtual type resolves expanded call to current type, not to virtual type - doesn't mix types of instance vars with initialize and new doesn't mix types of instance vars with initialize and new - codegens def with one default value codegens def with one default value -MacroExpander - expands macro with and (1) expands macro with and (1) - expands macro with string substitution expands macro with string substitution - expands macro with and (2) expands macro with and (2) - expands macro with char expands macro with char - for - expands macro with for over range literal expands macro with for over range literal - expands macro with for over array literal with index expands macro with for over array literal with index - expands macro with for over array literal expands macro with for over array literal - expands macro with for over range literal, evaluating elements expands macro with for over range literal, evaluating elements - expands macro with for over hash literal with index expands macro with for over hash literal with index - expands macro with for over tuple literal expands macro with for over tuple literal - expands macro with for over embedded array literal expands macro with for over embedded array literal - expands macro with for over range literal, evaluating elements (exclusive) expands macro with for over range literal, evaluating elements (exclusive) - expands macro with for over hash literal expands macro with for over hash literal - expands macro with argument-less call substitution expands macro with argument-less call substitution - if - expands macro with if with not expands macro with if with not - expands macro with if when truthy expands macro with if when truthy - expands macro with if else when falsey expands macro with if else when falsey - expands macro with if with nop expands macro with if with nop - expands macro with if when falsey expands macro with if when falsey - does not expand when macro expression is {% ... %} does not expand when macro expression is {% ... %} - expands macro with or (1) expands macro with or (1) - expands macro with symbol expands macro with symbol - expands macro with var substitution expands macro with var substitution - does regular unless does regular unless - does regular if does regular if - outputs invisible location pragmas outputs invisible location pragmas - expands simple macro expands simple macro - expands macro with tuple expands macro with tuple - expands macro with hash expands macro with hash - expands macro with symbol substitution expands macro with symbol substitution - expands macro with range expands macro with range - can't use `yield` outside a macro can't use `yield` outside a macro - expands macro with or (2) expands macro with or (2) - expands macro with boolean expands macro with boolean - expands macro with array expands macro with array - expands macro with string expands macro with string - expands macro with string interpolation expands macro with string interpolation - expands macro with nil expands macro with nil - expands macro with integer expands macro with integer +Normalize: return next break + doesn't remove after return when there's an unless doesn't remove after return when there's an unless + removes nodes after if that returns in both branches removes nodes after if that returns in both branches + removes nodes after break removes nodes after break + removes nodes after next removes nodes after next + doesn't remove nodes after if that returns in one branch doesn't remove nodes after if that returns in one branch + removes nodes after return removes nodes after return +Crystal::Repl::Interpreter + procs + interprets call inside Proc type interprets call inside Proc type + interprets proc literal with args interprets proc literal with args + can downcast Proc(T) to Proc(Nil) can downcast Proc(T) to Proc(Nil) + discards proc call discards proc call + interprets no args proc literal interprets no args proc literal + casts from nilable proc type to proc type casts from nilable proc type to proc type + does call without receiver inside closure does call without receiver inside closure + casts proc call arguments to proc arg types (#12350) casts proc call arguments to proc arg types (#12350) + calls proc primitive on union of module that has no subtypes (#12954) calls proc primitive on union of module that has no subtypes (#12954) +Normalize: chained comparisons + normalizes two comparisons with calls normalizes two comparisons with calls + normalizes one comparison with call normalizes one comparison with call + normalizes two comparisons with literal normalizes two comparisons with literal + normalizes one comparison with var normalizes one comparison with var + normalizes one comparison with literal normalizes one comparison with literal +Crystal::Repl::Interpreter + integration + does Float64#to_s (simple) does Float64#to_s (simple) + does caller does caller + does String#includes? does String#includes? + does CSV does CSV + does YAML::Serializable does YAML::Serializable + does Int32#to_s does Int32#to_s + does JSON does JSON + does IO.pipe (checks that StaticArray is passed correctly to C calls) does IO.pipe (checks that StaticArray is passed correctly to C calls) + does Float64#to_s (complex) does Float64#to_s (complex) + does XML does XML + does some Hash methods does some Hash methods + does YAML does YAML + does Range#to_a, Array#to_s does Range#to_a, Array#to_s + does JSON::Serializable does JSON::Serializable +Code gen: no return + codegens no return variable declaration (#1508) codegens no return variable declaration (#1508) + codegens if with no return and variable used afterwards codegens if with no return and variable used afterwards + codegens if with NoReturn on then and union on else codegens if with NoReturn on then and union on else + codegens untyped typeof (#5105) codegens untyped typeof (#5105) + codegens call with no return because of falsey if (#3661) codegens call with no return because of falsey if (#3661) + codegen types exception handler as NoReturn if ensure is NoReturn codegen types exception handler as NoReturn if ensure is NoReturn + codegens no return instance variable declaration (#1508) codegens no return instance variable declaration (#1508) + codegens Pointer(NoReturn).malloc codegens Pointer(NoReturn).malloc +Code gen: and + codegens and with primitive type other than bool with union codegens and with primitive type other than bool with union + codegens and with bool union as left node 3 codegens and with bool union as left node 3 + codegens and with non-false union as left node codegens and with non-false union as left node + codegens assign in right node, inside if must not be nil codegens assign in right node, inside if must not be nil + codegens and with bool union as left node 1 codegens and with bool union as left node 1 + codegens and with bool and int 1 codegens and with bool and int 1 + codegens assign in right node, after if must be nilable codegens assign in right node, after if must be nilable + codegens and with primitive type other than bool codegens and with primitive type other than bool + codegens and with bool true and false codegens and with bool true and false + codegens and with bool union as left node 1 codegens and with bool union as left node 1 + codegens and with bool union as left node 4 codegens and with bool union as left node 4 + codegens and with bool union as left node 3 codegens and with bool union as left node 3 + codegens and with nil union as left node 1 codegens and with nil union as left node 1 + codegens and with nil union as left node 2 codegens and with nil union as left node 2 + codegens and with bool and int 2 codegens and with bool and int 2 + codegens and with bool union as left node 2 codegens and with bool union as left node 2 + codegens and with nilable as left node 1 codegens and with nilable as left node 1 + codegens and with bool true and true codegens and with bool true and true + codegens and with bool false and false codegens and with bool false and false + codegens and with primitive type other than bool codegens and with primitive type other than bool + codegens and with bool union as left node 2 codegens and with bool union as left node 2 + codegens and with nilable as left node 2 codegens and with nilable as left node 2 + codegens assign in right node, after must be nilable codegens assign in right node, after must be nilable + codegens and with bool false and true codegens and with bool false and true +Normalize: or + normalizes or with is_a? on var normalizes or with is_a? on var + normalizes or with ! on var.is_a?(...) normalizes or with ! on var.is_a?(...) + normalizes or with variable on the left normalizes or with variable on the left + normalizes or with ! on var normalizes or with ! on var + normalizes or without variable normalizes or without variable + normalizes or with assignment on the left normalizes or with assignment on the left +Semantic: nil + can call a fun with nil for typedef pointer can call a fun with nil for typedef pointer + marks instance variables as nil but doesn't explode on macros marks instance variables as nil but doesn't explode on macros + marks instance variables as nil when not in initialize 2 marks instance variables as nil when not in initialize 2 + restricts type of 'while foo' restricts type of 'while foo' + restricts type of 'while foo' on assign restricts type of 'while foo' on assign + types nil types nil + types empty types empty + marks instance variables as nil when not in initialize marks instance variables as nil when not in initialize + restricts type of 'if foo' restricts type of 'if foo' + can call a fun with nil for pointer can call a fun with nil for pointer + restricts type of 'if foo' on assign restricts type of 'if foo' on assign + doesn't check return type for nil doesn't check return type for nil + doesn't check return type for void doesn't check return type for void Crystal::Repl::Interpreter responds_to? - doesn't crash if def body ends up with no type (#12219) doesn't crash if def body ends up with no type (#12219) does responds_to? does responds_to? -Codegen: private - codegens class var of private type with same name as public type (#11620) codegens class var of private type with same name as public type (#11620) - codegens private def in same file codegens private def in same file - codegens overloaded private def in same file codegens overloaded private def in same file - doesn't include filename for private types doesn't include filename for private types - codegens class vars of private types with same name (#11620) codegens class vars of private types with same name (#11620) -Lexer string array - lexes string array with new line gives correct column for next token lexes string array with new line gives correct column for next token - lexes simple string array lexes simple string array - using { as delimiter - lexes simple string array lexes simple string array - using [ as delimiter - lexes simple string array lexes simple string array - lexes string array with new line lexes string array with new line - using < as delimiter - lexes simple string array lexes simple string array - using | as delimiter - lexes simple string array lexes simple string array -Codegen: thread local - works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables works with class variables - works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread works with class variable in main thread - compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer compiles with class variable referenced from initializer -Lexer doc - lexes with doc enabled but without docs lexes with doc enabled but without docs - lexes with doc enabled and docs, one line comment with two newlines and another comment lexes with doc enabled and docs, one line comment with two newlines and another comment - lexes without doc enabled lexes without doc enabled - lexes with doc enabled and docs, two line comment with leading whitespace lexes with doc enabled and docs, two line comment with leading whitespace - lexes with doc enabled and docs lexes with doc enabled and docs - resets doc after non newline or space token resets doc after non newline or space token - lexes with doc enabled and docs, two line comment lexes with doc enabled and docs, two line comment -Codegen: double splat - evaluates double splat argument just once (#2677) evaluates double splat argument just once (#2677) - double splats named argument into arguments (1) double splats named argument into arguments (1) - double splats named argument with positional arguments double splats named argument with positional arguments - matches double splat with regular splat matches double splat with regular splat - double splats named argument into arguments (2) double splats named argument into arguments (2) - double splats twice double splats twice - matches double splat on method with named args matches double splat on method with named args - removes literal types in all matches (#6239) removes literal types in all matches (#6239) - double splats named argument with named args (2) double splats named argument with named args (2) - matches double splat on method with named args and regular args matches double splat on method with named args and regular args - double splats named argument with named args (1) double splats named argument with named args (1) -Semantic: union - types union when arg is union types union when arg is union - finds method in Value finds method in Value - errors if instantiates union errors if instantiates union - types union when both obj and arg are union types union when both obj and arg are union - merges types in the same hierarchy with Union merges types in the same hierarchy with Union - types union types union - treats void as nil in union treats void as nil in union - can iterate T can iterate T - assigns to union and keeps new union type in call assigns to union and keeps new union type in call - types union of same type types union of same type - doesn't run virtual lookup on unbound unions (#9173) doesn't run virtual lookup on unbound unions (#9173) - looks up type in union type with free var looks up type in union type with free var - can reopen Union and access T can reopen Union and access T - types union of classes types union of classes - can use Union in type restriction (#2988) can use Union in type restriction (#2988) - can reopen Union can reopen Union - doesn't virtualize union elements (#7814) doesn't virtualize union elements (#7814) - doesn't crash with union of no-types (#5805) doesn't crash with union of no-types (#5805) - supports macro if inside union supports macro if inside union - commutativity - uninstantiated generic super-metaclass v.s. uninstantiated generic sub-metaclass uninstantiated generic super-metaclass v.s. uninstantiated generic sub-metaclass - module v.s. including generic module instance module v.s. including generic module instance - module v.s. including module module v.s. including module - module v.s. extending generic module instance metaclass module v.s. extending generic module instance metaclass - generic module instance v.s. including generic module instance generic module instance v.s. including generic module instance - generic module instance v.s. including module generic module instance v.s. including module - virtual metaclass v.s. generic subclass instance metaclass virtual metaclass v.s. generic subclass instance metaclass - generic module instance v.s. extending generic module instance metaclass generic module instance v.s. extending generic module instance metaclass - superclass v.s. uninstantiated generic subclass superclass v.s. uninstantiated generic subclass - finds method in Object finds method in Object - types union when obj is union types union when obj is union -Semantic: require - file not found - require require - relative require relative require - wildcard wildcard - relative wildcard relative wildcard -Code gen: op assign - evaluates exps once (#3398) evaluates exps once (#3398) - evaluates exps once, [] (#3398) evaluates exps once, [] (#3398) -Lexer - lexes "true" lexes "true" - lexes "==" lexes "==" - lexes ":\"foo\"" lexes ":\"foo\"" - lexes "1i16" lexes "1i16" - lexes "def" lexes "def" - lexes "0" lexes "0" - says syntax error on "'" says syntax error on "'" - lexes "bar!" lexes "bar!" - lexes "private" lexes "private" - lexes "{" lexes "{" - lexes "$10?" lexes "$10?" - says syntax error on "2e+e" says syntax error on "2e+e" - lexes ":**" lexes ":**" - lexes "break" lexes "break" - lexes "next" lexes "next" - lexes "-0x8000000000000000_i64" lexes "-0x8000000000000000_i64" - lexes "|" lexes "|" - says syntax error on "-3_" says syntax error on "-3_" - lexes "for" lexes "for" - lexes "1i32" lexes "1i32" - lexes "**" lexes "**" - says syntax error on "0x100000000i32" says syntax error on "0x100000000i32" - lexes "yield!" lexes "yield!" - lexes "then" lexes "then" - lexes "while" lexes "while" - lexes "-0" lexes "-0" - lexes "0o700000000000000000000" lexes "0o700000000000000000000" - lexes "0x1_i64" lexes "0x1_i64" - lexes '\\' lexes '\\' - says syntax error on "65536_u16" says syntax error on "65536_u16" - lexes "340282366920938463463374607431768211455_u128" lexes "340282366920938463463374607431768211455_u128" - lexes "next!" lexes "next!" - says syntax error on "$0?" says syntax error on "$0?" - lexes "->" lexes "->" - lexes "begin!" lexes "begin!" - lexes "while?" lexes "while?" - lexes ":&-" lexes ":&-" - lexes "1" lexes "1" - lexes "1u64" lexes "1u64" - lexes "+0b1010" lexes "+0b1010" - says syntax error on "18446744073709551616" says syntax error on "18446744073709551616" - lexes "{{" lexes "{{" - lexes "0b100000000000000000000000000000000" lexes "0b100000000000000000000000000000000" - lexes symbol with quote lexes symbol with quote - lexes "super" lexes "super" - says syntax error on "2e+f32" says syntax error on "2e+f32" - lexes ":!" lexes ":!" - lexes "-1234" lexes "-1234" - says syntax error on "0o12345671234567_12345671234567_i8" says syntax error on "0o12345671234567_12345671234567_i8" - says syntax error on "4f65" says syntax error on "4f65" - lexes '\0' lexes '\0' - lexes "\x12" lexes "\x12" - lexes "@@foo" lexes "@@foo" - lexes "<<" lexes "<<" - lexes "extend" lexes "extend" - lexes "if" lexes "if" - lexes "~" lexes "~" - lexes "lib" lexes "lib" - says syntax error on "4f22" says syntax error on "4f22" - says syntax error on "-1_u32" says syntax error on "-1_u32" - says syntax error on "9999999999999999999_i32" says syntax error on "9999999999999999999_i32" - lexes "0🔮" lexes "0🔮" - lexes "||=" lexes "||=" - lexes "170141183460469231731687303715884105727_i128" lexes "170141183460469231731687303715884105727_i128" - lexes "::" lexes "::" - lexes "fun" lexes "fun" - lexes "1i128" lexes "1i128" - lexes "+1.0" lexes "+1.0" - lexes "0.5" lexes "0.5" - lexes "-" lexes "-" - lexes "0x100000000" lexes "0x100000000" - lexes symbol followed by == lexes symbol followed by == - lexes "-1" lexes "-1" - lexes "elsif?" lexes "elsif?" - lexes ":===" lexes ":===" - lexes ":^" lexes ":^" - lexes "offsetof" lexes "offsetof" - lexes "&-=" lexes "&-=" - lexes "@foo" lexes "@foo" - says syntax error on "\"\\xz\"" says syntax error on "\"\\xz\"" - lexes "2147483648.foo" lexes "2147483648.foo" - lexes '\t' lexes '\t' - lexes "false!" lexes "false!" - lexes "return" lexes "return" - says syntax error on "'\\uDFFF'" says syntax error on "'\\uDFFF'" - lexes "|=" lexes "|=" - lexes "break!" lexes "break!" - says syntax error on "-0u64" says syntax error on "-0u64" - lexes "/" lexes "/" - says syntax error on "'\\u{D800}'" says syntax error on "'\\u{D800}'" - lexes "false?" lexes "false?" - lexes "uninitialized" lexes "uninitialized" - says syntax error on "0xFF_i8" says syntax error on "0xFF_i8" - lexes "annotation" lexes "annotation" - lexes "0i32" lexes "0i32" - lexes "nil!" lexes "nil!" - lexes "responds_to?" lexes "responds_to?" - lexes "1i64" lexes "1i64" - says syntax error on "0b100000000000000000000000000000000i32" says syntax error on "0b100000000000000000000000000000000i32" - lexes "yield?" lexes "yield?" - says syntax error on "0b10000000_i8" says syntax error on "0b10000000_i8" - lexes "//=" lexes "//=" - lexes ":<" lexes ":<" - lexes "1i64hello" lexes "1i64hello" - lexes "9223372036854775808" lexes "9223372036854775808" - lexes "def!" lexes "def!" - lexes "while!" lexes "while!" - doesn't raise if many slash r with slash n doesn't raise if many slash r with slash n - says syntax error on "10e_10" says syntax error on "10e_10" - lexes "+1_i128" lexes "+1_i128" - lexes "2147483648" lexes "2147483648" - lexes "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_u128" lexes "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_u128" - lexes "begin" lexes "begin" - lexes "with_underscores" lexes "with_underscores" - says syntax error on "0_12" says syntax error on "0_12" - lexes ":*" lexes ":*" - lexes "1.0" lexes "1.0" - says syntax error on "-1_u8" says syntax error on "-1_u8" - says syntax error on "-1_u64" says syntax error on "-1_u64" - lexes "1i64" lexes "1i64" - lexes "+1234" lexes "+1234" - says syntax error on "\"\\400\"" says syntax error on "\"\\400\"" - lexes "1u16" lexes "1u16" - lexes "0x7fffffff_i32" lexes "0x7fffffff_i32" - lexes space after char lexes space after char - lexes "begin?" lexes "begin?" - says syntax error on "4.0_u32" says syntax error on "4.0_u32" - lexes "<" lexes "<" - lexes "\n\n\n" lexes "\n\n\n" - lexes "<<=" lexes "<<=" - says syntax error on "4294967296_u32" says syntax error on "4294967296_u32" - lexes "**=" lexes "**=" - says syntax error on "\"hi\\" says syntax error on "\"hi\\" - lexes "end!" lexes "end!" - lexes "10000000000000000000_u64" lexes "10000000000000000000_u64" - lexes "1_i64" lexes "1_i64" - lexes "1234" lexes "1234" - says syntax error on "4i22" says syntax error on "4i22" - lexes "+1.0f32" lexes "+1.0f32" - lexes "0b1000000000000000000000000000000000000000000000000000000000000000" lexes "0b1000000000000000000000000000000000000000000000000000000000000000" - says syntax error on "01_i64" says syntax error on "01_i64" - lexes "&&=" lexes "&&=" - lexes "include" lexes "include" - lexes "0o40000000000" lexes "0o40000000000" - lexes ":-" lexes ":-" - lexes "2_e2" lexes "2_e2" - lexes "of" lexes "of" - lexes "-0xFFFF" lexes "-0xFFFF" - lexes ":%" lexes ":%" - lexes ":&*" lexes ":&*" - lexes "is_a?" lexes "is_a?" - lexes "1u128" lexes "1u128" - lexes ">>=" lexes ">>=" - lexes "-1.0f32" lexes "-1.0f32" - lexes "://" lexes "://" - lexes "nil?" lexes "nil?" - says syntax error on "0o1234567123456712345671234567u64" says syntax error on "0o1234567123456712345671234567u64" - lexes '\b' lexes '\b' - lexes ":!=" lexes ":!=" - lexes "0o17777777777_i32" lexes "0o17777777777_i32" - lexes "1.0hello" lexes "1.0hello" - lexes "$foo123" lexes "$foo123" - says syntax error on "\"\\x1z\"" says syntax error on "\"\\x1z\"" - lexes "0xabcdef" lexes "0xabcdef" - lexes "break?" lexes "break?" - says syntax error on "0o73_f64" says syntax error on "0o73_f64" - lexes "$1" lexes "$1" - lexes "return!" lexes "return!" - lexes "$1?" lexes "$1?" - lexes __DIR__ lexes __DIR__ - lexes "1.2e+23_f32" lexes "1.2e+23_f32" - lexes "0_i32" lexes "0_i32" - lexes != after identifier (#4815) lexes != after identifier (#4815) - lexes "0b11111111111111111111111111111111" lexes "0b11111111111111111111111111111111" - lexes "until" lexes "until" - says syntax error on "$01" says syntax error on "$01" - lexes "macro" lexes "macro" - lexes __FILE__ lexes __FILE__ - says syntax error on "'\\u{DFFF}'" says syntax error on "'\\u{DFFF}'" - lexes "," lexes "," - lexes "{%" lexes "{%" - lexes "-0x80000000000000000000000000000000_i128" lexes "-0x80000000000000000000000000000000_i128" - lexes "|" lexes "|" - says syntax error on "'\\" says syntax error on "'\\" - lexes "12341234🔮" lexes "12341234🔮" - lexes ":かたな" lexes ":かたな" - lexes "next?" lexes "next?" - says syntax error on "18446744073709551616_u64" says syntax error on "18446744073709551616_u64" - says syntax error on "0x10000_0000_0000_0000" says syntax error on "0x10000_0000_0000_0000" - lexes "enum" lexes "enum" - says syntax error on ":\"foo" says syntax error on ":\"foo" - lexes "\8" lexes "\8" - says syntax error on "0b100000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000" says syntax error on "0b100000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000" - lexes regex after \r\n lexes regex after \r\n - lexes "&-@foo" lexes "&-@foo" - says syntax error on "4F32" says syntax error on "4F32" - lexes "\n" lexes "\n" - lexes float then zero (bug) lexes float then zero (bug) - lexes "0xffffffff" lexes "0xffffffff" - lexes '\n' lexes '\n' - lexes "0b001111111111111111111111111111111111111111111111111111111111111111" lexes "0b001111111111111111111111111111111111111111111111111111111111111111" - lexes "with_1" lexes "with_1" - lexes ":<=" lexes ":<=" - lexes "1_i16" lexes "1_i16" - lexes "0b1_i64" lexes "0b1_i64" - says syntax error on "4i3" says syntax error on "4i3" - says syntax error on "'\\u{}'" says syntax error on "'\\u{}'" - says syntax error on "0b🔮" says syntax error on "0b🔮" - lexes "do?" lexes "do?" - says syntax error on "-0x80000000000000000000000000000001" says syntax error on "-0x80000000000000000000000000000001" - says syntax error on "-0x80000000000000000000000000000000" says syntax error on "-0x80000000000000000000000000000000" - lexes "9223372036854775807" lexes "9223372036854775807" - lexes "\t" lexes "\t" - says syntax error on "4F64" says syntax error on "4F64" - lexes "if!" lexes "if!" - lexes "true!" lexes "true!" - lexes "<=>" lexes "<=>" - lexes "if?" lexes "if?" - lexes "0x00ffffffffffffffff" lexes "0x00ffffffffffffffff" - lexes "+0xFFFF" lexes "+0xFFFF" - lexes "-0o123" lexes "-0o123" - lexes "&=" lexes "&=" - says syntax error on "0b11_f32" says syntax error on "0b11_f32" - lexes "&+" lexes "&+" - says syntax error on "-.42" says syntax error on "-.42" - says syntax error on "'\\uD800'" says syntax error on "'\\uD800'" - says syntax error on "1__1" says syntax error on "1__1" - lexes symbol with backslash (#2187) lexes symbol with backslash (#2187) - lexes "0o1000000000000000000000" lexes "0o1000000000000000000000" - lexes "}" lexes "}" - lexes "rescue" lexes "rescue" - lexes "-@foo" lexes "-@foo" - lexes "fooBar" lexes "fooBar" - lexes "module" lexes "module" - lexes ":!~" lexes ":!~" - lexes "unless!" lexes "unless!" - lexes "&*=" lexes "&*=" - lexes "_" lexes "_" - says syntax error on "0123" says syntax error on "0123" - lexes __LINE__ lexes __LINE__ - says syntax error on "0o1000000000000000000000i64" says syntax error on "0o1000000000000000000000i64" - lexes "9223372036854775808_i128" lexes "9223372036854775808_i128" - lexes "=>" lexes "=>" - says syntax error on "\r1" says syntax error on "\r1" - lexes "!" lexes "!" - says syntax error on "4u33" says syntax error on "4u33" - lexes "1.2e+23" lexes "1.2e+23" - says syntax error on ":+1" says syntax error on ":+1" - says syntax error on "2e+_2" says syntax error on "2e+_2" - lexes ":+" lexes ":+" - lexes "$23?" lexes "$23?" - lexes "unless" lexes "unless" - lexes "0o123_i64" lexes "0o123_i64" - lexes "-1_i128" lexes "-1_i128" - lexes ":" lexes ":" - says syntax error on "2e+@foo" says syntax error on "2e+@foo" - says syntax error on "4u3" says syntax error on "4u3" - lexes ":foo?" lexes ":foo?" - lexes "0x10000_0000_0000_0000_i128" lexes "0x10000_0000_0000_0000_i128" - says syntax error on "-9223372036854775809" says syntax error on "-9223372036854775809" - says syntax error on "0x1afafafafafafafafafafaf" says syntax error on "0x1afafafafafafafafafafaf" - lexes "*=" lexes "*=" - lexes "asm" lexes "asm" - says syntax error on "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" says syntax error on "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" - lexes "1u32" lexes "1u32" - lexes "1_u128" lexes "1_u128" - invalid byte sequence invalid byte sequence - lexes ":>>" lexes ":>>" - lexes "100_000" lexes "100_000" - lexes "1.0f32" lexes "1.0f32" - lexes "in" lexes "in" - says syntax error on "0b100000000000000000000000000000000000000000000000000000000000000000" says syntax error on "0b100000000000000000000000000000000000000000000000000000000000000000" - lexes "!@foo" lexes "!@foo" - lexes "&+@foo" lexes "&+@foo" - says syntax error on "-0e_12" says syntax error on "-0e_12" - lexes ":~" lexes ":~" - lexes "0o17777777777" lexes "0o17777777777" - says syntax error on "0o200000_00000000_00000000_u64" says syntax error on "0o200000_00000000_00000000_u64" - says syntax error on "0o7777777777777777777777777777777777777777777777777" says syntax error on "0o7777777777777777777777777777777777777777777777777" - lexes "18446744073709551616_u128" lexes "18446744073709551616_u128" - lexes "1e23f64" lexes "1e23f64" - lexes "❨╯°□°❩╯︵┻━┻" lexes "❨╯°□°❩╯︵┻━┻" - lexes "do!" lexes "do!" - says syntax error on "32768_i16" says syntax error on "32768_i16" - says syntax error on "-9999999999999999999" says syntax error on "-9999999999999999999" - lexes "+=" lexes "+=" - lexes "-0.0f32" lexes "-0.0f32" - lexes "0o001777777777777777777777" lexes "0o001777777777777777777777" - says syntax error on "0b1000000000000000000000000000000000000000000000000000000000000000i64" says syntax error on "0b1000000000000000000000000000000000000000000000000000000000000000i64" - lexes '\r' lexes '\r' - says syntax error on "'\\1'" says syntax error on "'\\1'" - lexes "-2147483649" lexes "-2147483649" - lexes "!~" lexes "!~" - lexes ".." lexes ".." - lexes "protected" lexes "protected" - lexes ">" lexes ">" - says syntax error on "/\\" says syntax error on "/\\" - lexes "out" lexes "out" - says syntax error on "18446744073709551616_i32" says syntax error on "18446744073709551616_i32" - lexes "^=" lexes "^=" - lexes "case" lexes "case" - lexes "1e-23" lexes "1e-23" - lexes "typeof" lexes "typeof" - lexes "-0.5" lexes "-0.5" - lexes "type" lexes "type" - lexes "[" lexes "[" - lexes "1_u64" lexes "1_u64" - says syntax error on "-2147483649_i32" says syntax error on "-2147483649_i32" - lexes "..." lexes "..." - lexes "something" lexes "something" - says syntax error on "2e+-2" says syntax error on "2e+-2" - lexes "$10" lexes "$10" - lexes "(" lexes "(" - says syntax error on "2e+" says syntax error on "2e+" - lexes "1e+23" lexes "1e+23" - lexes "/=" lexes "/=" - lexes "0e40" lexes "0e40" - lexes "as?" lexes "as?" - lexes "-9223372036854775808" lexes "-9223372036854775808" - says syntax error on "0o200_i8" says syntax error on "0o200_i8" - lexes "0xffffffffffffffff" lexes "0xffffffffffffffff" - lexes "\xFF" lexes "\xFF" - lexes "union" lexes "union" - lexes "verbatim" lexes "verbatim" - lexes "\4" lexes "\4" - lexes "[]=" lexes "[]=" - lexes "self" lexes "self" - lexes "2e01" lexes "2e01" - lexes regex after \n lexes regex after \n - lexes "0x7fffffffffffffff" lexes "0x7fffffffffffffff" - lexes "$_foo" lexes "$_foo" - lexes "else!" lexes "else!" - says syntax error on "-0_u64" says syntax error on "-0_u64" - lexes "1_000" lexes "1_000" - says syntax error on "0xfffffffffffffffff_u64" says syntax error on "0xfffffffffffffffff_u64" - lexes "1.0f32hello" lexes "1.0f32hello" - lexes comment at the end lexes comment at the end - lexes "0f32" lexes "0f32" - lexes '\v' lexes '\v' - lexes '\f' lexes '\f' - lexes "\110" lexes "\110" - says syntax error on "2e" says syntax error on "2e" - lexes "yield" lexes "yield" - lexes "+0o123" lexes "+0o123" - lexes "%" lexes "%" - says syntax error on "1_.1" says syntax error on "1_.1" - lexes ":[]=" lexes ":[]=" - lexes char with unicode codepoint and curly with six hex digits lexes char with unicode codepoint and curly with six hex digits - says syntax error on ".42" says syntax error on ".42" - lexes "elsif" lexes "elsif" - lexes "-1_i64" lexes "-1_i64" - lexes "ensure" lexes "ensure" - lexes "0b1111111111111111111111111111111_i32" lexes "0b1111111111111111111111111111111_i32" - lexes space after keyword lexes space after keyword - lexes ":foo!" lexes ":foo!" - lexes "return?" lexes "return?" - lexes "<=" lexes "<=" - lexes "else" lexes "else" - says syntax error on "9223372036854775808_i64" says syntax error on "9223372036854775808_i64" - lexes '\a' lexes '\a' - says syntax error on "4u12" says syntax error on "4u12" - lexes "1_i8" lexes "1_i8" - lexes "0x80000001" lexes "0x80000001" - lexes "1i128hello" lexes "1i128hello" - lexes "+" lexes "+" - lexes "@[" lexes "@[" - says syntax error on "118446744073709551616" says syntax error on "118446744073709551616" - lexes ":&+" lexes ":&+" - lexes 'a' lexes 'a' - lexes "-0b1010" lexes "-0b1010" - lexes "-0x80000001" lexes "-0x80000001" - says syntax error on "00" says syntax error on "00" - lexes "]" lexes "]" - says syntax error on "'\\u{110000}'" says syntax error on "'\\u{110000}'" - lexes "0xffff_ffff_ffff_ffff" lexes "0xffff_ffff_ffff_ffff" - lexes "^" lexes "^" - says syntax error on "128_i8" says syntax error on "128_i8" - lexes ":<=>" lexes ":<=>" - lexes "0o177777_77777777_77777777" lexes "0o177777_77777777_77777777" - says syntax error on "0b100000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_u64" says syntax error on "0b100000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_u64" - lexes ">=" lexes ">=" - lexes "0x3🔮" lexes "0x3🔮" - lexes "sizeof" lexes "sizeof" - lexes "1_u32" lexes "1_u32" - says syntax error on "-170141183460469231731687303715884105729" says syntax error on "-170141183460469231731687303715884105729" - says syntax error on "0o1234567123456712345671234567" says syntax error on "0o1234567123456712345671234567" - says syntax error on "0b100000000000000000000000000000000000000000000000000000000000000000u64" says syntax error on "0b100000000000000000000000000000000000000000000000000000000000000000u64" - says syntax error on "0o200000_00000000_00000000" says syntax error on "0o200000_00000000_00000000" - lexes "0o1000000000000000000000" lexes "0o1000000000000000000000" - lexes ":>=" lexes ":>=" - lexes "when" lexes "when" - lexes "14146167139683460000" lexes "14146167139683460000" - lexes "1_234.567_890" lexes "1_234.567_890" - lexes "1e23" lexes "1e23" - says syntax error on "-0o7777777777777777777777777777777777777777777777777" says syntax error on "-0o7777777777777777777777777777777777777777777777777" - lexes ":==" lexes ":==" - lexes "else?" lexes "else?" - lexes "class!" lexes "class!" - lexes "ident" lexes "ident" - lexes "[]?" lexes "[]?" - lexes "alias" lexes "alias" - says syntax error on "4u65" says syntax error on "4u65" - lexes char with unicode codepoint lexes char with unicode codepoint - lexes "0b0_1" lexes "0b0_1" - lexes "0i8" lexes "0i8" - lexes symbol followed by != lexes symbol followed by != - lexes "0b111111111111111111111111111111111111111111111111111111111111111" lexes "0b111111111111111111111111111111111111111111111111111111111111111" - lexes ":&**" lexes ":&**" - lexes "as" lexes "as" - lexes "false" lexes "false" - lexes "\1" lexes "\1" - lexes "118446744073709551616_u128" lexes "118446744073709551616_u128" - lexes "+1_i64" lexes "+1_i64" - lexes "0_f32" lexes "0_f32" - lexes "0b1111111111111111111111111111111" lexes "0b1111111111111111111111111111111" - lexes "0xFFFFFFFF" lexes "0xFFFFFFFF" - lexes "1E40" lexes "1E40" - lexes "instance_sizeof" lexes "instance_sizeof" - lexes comment and token lexes comment and token - lexes "&-" lexes "&-" - lexes "=" lexes "=" - lexes "pointerof" lexes "pointerof" - lexes "&" lexes "&" - says syntax error on "-9223372036854775809_i64" says syntax error on "-9223372036854775809_i64" - lexes "+0.5" lexes "+0.5" - lexes "struct" lexes "struct" - lexes char with unicode codepoint and curly lexes char with unicode codepoint and curly - lexes "1.2e+23_f64" lexes "1.2e+23_f64" - lexes "*" lexes "*" - lexes "1f32" lexes "1f32" - says syntax error on "'\\uFEDZ'" says syntax error on "'\\uFEDZ'" - lexes ">>" lexes ">>" - says syntax error on "-99999999999999999999" says syntax error on "-99999999999999999999" - lexes "&*" lexes "&*" - lexes ":&" lexes ":&" - says syntax error on "0o40000000000i32" says syntax error on "0o40000000000i32" - lexes "170141183460469231731687303715884105728_u128" lexes "170141183460469231731687303715884105728_u128" - doesn't raise if slash r with slash n doesn't raise if slash r with slash n - lexes "?" lexes "?" - says syntax error on "0x1afafafafafafafafafafafu64" says syntax error on "0x1afafafafafafafafafafafu64" - lexes ":>" lexes ":>" - lexes "||" lexes "||" - lexes dot and ident lexes dot and ident - lexes "." lexes "." - lexes "-1.0" lexes "-1.0" - lexes ";" lexes ";" - lexes "require" lexes "require" - says syntax error on "0x8000000000000000i64" says syntax error on "0x8000000000000000i64" - lexes ":/" lexes ":/" - says syntax error on "0b_10" says syntax error on "0b_10" - lexes "with" lexes "with" - lexes "0o777777777777777777777" lexes "0o777777777777777777777" - lexes "class" lexes "class" - lexes "abstract" lexes "abstract" - lexes "$?" lexes "$?" - lexes "unless?" lexes "unless?" - lexes ":=~" lexes ":=~" - lexes "-=" lexes "-=" - says syntax error on "340282366920938463463374607431768211456" says syntax error on "340282366920938463463374607431768211456" - lexes "&&" lexes "&&" - lexes "def?" lexes "def?" - lexes "+0" lexes "+0" - lexes "1_234.567_890_f32" lexes "1_234.567_890_f32" - lexes "&+=" lexes "&+=" - says syntax error on "/foo" says syntax error on "/foo" - lexes "1f64" lexes "1f64" - says syntax error on "-1_u16" says syntax error on "-1_u16" - lexes "0o123" lexes "0o123" - lexes ")" lexes ")" - lexes ":foo=" lexes ":foo=" - says syntax error on "-1_u128" says syntax error on "-1_u128" - lexes "!=" lexes "!=" - lexes "1.0f64" lexes "1.0f64" - says syntax error on "2ef32" says syntax error on "2ef32" - lexes ":|" lexes ":|" - says syntax error on "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" says syntax error on "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" - lexes "0b1010" lexes "0b1010" - lexes "" lexes "" - lexes "true?" lexes "true?" - says syntax error on "2e8i8" says syntax error on "2e8i8" - lexes utf-8 multibyte char lexes utf-8 multibyte char - lexes '\0' lexes '\0' - says syntax error on "4f33" says syntax error on "4f33" - lexes "do" lexes "do" - lexes "+@foo" lexes "+@foo" - says syntax error on "2147483648_i32" says syntax error on "2147483648_i32" - lexes "elsif!" lexes "elsif!" - lexes "0x8000000000000000" lexes "0x8000000000000000" - says syntax error on "4u22" says syntax error on "4u22" - lexes "select" lexes "select" - lexes char with unicode codepoint and curly with zeros lexes char with unicode codepoint and curly with zeros - lexes "1.0f32" lexes "1.0f32" - lexes ":foo" lexes ":foo" - lexes "end" lexes "end" - says syntax error on "-32769_i16" says syntax error on "-32769_i16" - lexes "1_u8" lexes "1_u8" - lexes "[]" lexes "[]" - lexes "1i8" lexes "1i8" - says syntax error on "4i33" says syntax error on "4i33" - says syntax error on "0x1afafafafafafafafafafafi32" says syntax error on "0x1afafafafafafafafafafafi32" - says syntax error on "0F32" says syntax error on "0F32" - lexes "0xFFFF_u64" lexes "0xFFFF_u64" - lexes "0o37777777777" lexes "0o37777777777" - lexes "$~" lexes "$~" - lexes "1.foo" lexes "1.foo" - lexes "1u8" lexes "1u8" - lexes ":<<" lexes ":<<" - lexes "%}" lexes "%}" - says syntax error on "-11111111111111111111" says syntax error on "-11111111111111111111" - lexes "$FOO" lexes "$FOO" - says syntax error on "4i12" says syntax error on "4i12" - lexes " " lexes " " - lexes "1_i32" lexes "1_i32" - lexes ":[]?" lexes ":[]?" - lexes "=~" lexes "=~" - says syntax error on "-999999999999999999999999999999999999999" says syntax error on "-999999999999999999999999999999999999999" - lexes "%=" lexes "%=" - lexes "class?" lexes "class?" - lexes "foo?" lexes "foo?" - lexes '\'' lexes '\'' - lexes "===" lexes "===" - lexes "nil" lexes "nil" - lexes heredoc start lexes heredoc start - lexes "end?" lexes "end?" - lexes "1_u16" lexes "1_u16" - lexes "0x3fffffffffffffff" lexes "0x3fffffffffffffff" - lexes "Foo" lexes "Foo" - lexes "1_i64" lexes "1_i64" - lexes symbol followed by === lexes symbol followed by === - says syntax error on "256_u8" says syntax error on "256_u8" - lexes "1e+23_f32" lexes "1e+23_f32" - says syntax error on "118446744073709551616_u64" says syntax error on "118446744073709551616_u64" - lexes "+1" lexes "+1" - lexes utf-8 char lexes utf-8 char - says syntax error on "4i65" says syntax error on "4i65" - lexes "//" lexes "//" - lexes "-9223372036854775809_i128" lexes "-9223372036854775809_i128" - lexes "0xFFFF" lexes "0xFFFF" - says syntax error on "0x10000_0000_0000_0000_u64" says syntax error on "0x10000_0000_0000_0000_u64" - lexes not instance var lexes not instance var - lexes "1_i128" lexes "1_i128" - says syntax error on "-129_i8" says syntax error on "-129_i8" - lexes "18446744073709551615" lexes "18446744073709551615" - lexes "&**" lexes "&**" - lexes "$foo" lexes "$foo" - lexes "1hello" lexes "1hello" - lexes "\10" lexes "\10" - lexes "0x7fffffff" lexes "0x7fffffff" - lexes "-0xFFFFFFFF" lexes "-0xFFFFFFFF" - lexes ":[]" lexes ":[]" - lexes "0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111111" lexes "0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111111" + doesn't crash if def body ends up with no type (#12219) doesn't crash if def body ends up with no type (#12219) +Crystal + normalize_path + assert assert + assert assert + assert assert + assert assert +Semantic: enum + errors if defining initialize in Enum (#7238) errors if defining initialize in Enum (#7238) + errors on enum without members (#3447) errors on enum without members (#3447) + creates enum from value creates enum from value + errors if declaring type inside enum (#3127) errors if declaring type inside enum (#3127) + marks as flags with base type (#2185) marks as flags with base type (#2185) + gives error on signed flags enum overflow after a member with value gives error on signed flags enum overflow after a member with value + attaches annotation to enum method (#6690) attaches annotation to enum method (#6690) + gives error on enum overflow after a member with value gives error on enum overflow after a member with value + has All value when defined as @[Flags] has All value when defined as @[Flags] + reopens enum with same base type (1) reopens enum with same base type (1) + reopens enum without base type (1) reopens enum without base type (1) + doesn't error when defining a flags enum in a lib with None or All doesn't error when defining a flags enum in a lib with None or All + allows redefining None to 0 for @[Flags] enum allows redefining None to 0 for @[Flags] enum + can redefine Enum.new can redefine Enum.new + can use macro for inside enum can use macro for inside enum + types enum types enum + doesn't error when defining a method for an enum with flags doesn't error when defining a method for an enum with flags + gives error on flags enum overflow gives error on flags enum overflow + errors if reopen and tries to define constant errors if reopen and tries to define constant + errors if invoking private enum method errors if invoking private enum method + errors if using a name twice errors if using a name twice + defines method on enum defines method on enum + disallows implicit conversion of int to enum disallows implicit conversion of int to enum + reopens enum without base type (2) reopens enum without base type (2) + errors if reopen but not enum errors if reopen but not enum + doesn't break assigned values in enum flags when a member has value 0 (#5767) doesn't break assigned values in enum flags when a member has value 0 (#5767) + reopens an enum reopens an enum + doesn't overflow on flags member (#7877) doesn't overflow on flags member (#7877) + errors if inheriting Enum (#3592) errors if inheriting Enum (#3592) + errors if enum value is too big for type (#678) errors if enum value is too big for type (#678) + doesn't overflow when going from negative to zero (#7874) doesn't overflow when going from negative to zero (#7874) + errors if declaring type inside enum, nested (#3127) errors if declaring type inside enum, nested (#3127) + doesn't visit enum members generated by macros twice (#10104) doesn't visit enum members generated by macros twice (#10104) + can use macro expression inside enum can use macro expression inside enum + defines class method on enum defines class method on enum + errors if using instance var inside enum (#991) errors if using instance var inside enum (#991) + finds method in enum type finds method in enum type + errors if reopening enum with different base type (2) errors if reopening enum with different base type (2) + gives error on enum overflow gives error on enum overflow + gives error on unsigned flags enum overflow after a member with value gives error on unsigned flags enum overflow after a member with value + finds class method in enum type finds class method in enum type + disallows All value for @[Flags] enum disallows All value for @[Flags] enum + types enum value types enum value + has None value when defined as @[Flags] has None value when defined as @[Flags] + reopens enum with same base type (2) reopens enum with same base type (2) + doesn't error when defining a non-flags enum with None or All doesn't error when defining a non-flags enum with None or All + allows class vars in enum allows class vars in enum + disallows redefining None to non-0 for @[Flags] enum disallows redefining None to non-0 for @[Flags] enum + errors if reopening enum with different base type (1) errors if reopening enum with different base type (1) +Semantic: var + declares local variable and assigns wrong type declares local variable and assigns wrong type + declares local variable but doesn't assign it in all branches declares local variable but doesn't assign it in all branches + errors if declaring var that is already declared errors if declaring var that is already declared + types a variable types a variable + declares local variable with value declares local variable with value + reports undefined local variable or method reports undefined local variable or method + reports variable always nil reports variable always nil + parse local variable as method call even if local variable is declared in call arguments parse local variable as method call even if local variable is declared in call arguments + types an assign types an assign + lets type on else side of if with a Bool | Nil union lets type on else side of if with a Bool | Nil union + declares local variable and assigns it with if declares local variable and assigns it with if + types an assign with type declaration types an assign with type declaration + declares local variable and immediately reads it declares local variable and immediately reads it + reports there's no self reports there's no self + errors if reads from underscore errors if reads from underscore + errors if declaring generic type without type vars (with local var) errors if declaring generic type without type vars (with local var) + declares local variable and then assigns it declares local variable and then assigns it + errors if variable already exists errors if variable already exists +Semantic: nilable instance var + says instance var was not initialized in all of the initialize methods, with var declaration says instance var was not initialized in all of the initialize methods, with var declaration + says instance var was used before initialized says instance var was used before initialized + says self was used before instance var was initialized (3) says self was used before instance var was initialized (3) + says self was used before instance var was initialized (2) says self was used before instance var was initialized (2) + says instance var was used before initialized (2) says instance var was used before initialized (2) + says instance var was not initialized in all of the initialize methods says instance var was not initialized in all of the initialize methods + finds type that doesn't initialize instance var (#1222) finds type that doesn't initialize instance var (#1222) + says self was used before instance var was initialized says self was used before instance var was initialized + marks instance var as nilable if assigned inside proc literal marks instance var as nilable if assigned inside proc literal + doesn't consider as nil if initialized with catch-all doesn't consider as nil if initialized with catch-all + marks instance var as nilable if assigned inside captured block (#1696) marks instance var as nilable if assigned inside captured block (#1696) + says instance var was not initialized in all of the initialize methods (2) says instance var was not initialized in all of the initialize methods (2) +Code gen: c union + codegens union property default value 2 codegens union property default value 2 + aligns to the member with biggest align requirements aligns to the member with biggest align requirements + codegens union property setter 1 codegens union property setter 1 + automatically converts numeric union type in field assignment automatically converts numeric union type in field assignment + automatically converts by invoking to_unsafe automatically converts by invoking to_unsafe + codegens union property setter 2 codegens union property setter 2 + codegens union property default value codegens union property default value + builds union setter with fun type builds union setter with fun type + codegens union property setter 2 via pointer codegens union property setter 2 via pointer + codegens struct inside union codegens struct inside union + moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) + automatically converts numeric type in field assignment automatically converts numeric type in field assignment + codegens assign c union to union codegens assign c union to union + reads union instance var reads union instance var + does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s + codegens union property setter 1 via pointer codegens union property setter 1 via pointer + fills union type to the max size fills union type to the max size +Code gen: named tuple + codegens tuple nilable index (1) codegens tuple nilable index (1) + upcasts named tuple inside compatible named tuple upcasts named tuple inside compatible named tuple + upcasts named tuple inside union to union with compatible named tuple upcasts named tuple inside union to union with compatible named tuple + passes named tuple to def passes named tuple to def + downcasts union inside tuple to value (#3907) downcasts union inside tuple to value (#3907) + codegens tuple nilable index (3) codegens tuple nilable index (3) + upcasts named tuple union to compatible named tuple upcasts named tuple union to compatible named tuple + does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class + assigns two same-size named tuple types to a same var (#3132) assigns two same-size named tuple types to a same var (#3132) + allows named tuple covariance allows named tuple covariance + merges two named tuple types with same keys but different types (1) merges two named tuple types with same keys but different types (1) + provides T as a named tuple literal provides T as a named tuple literal + assigns named tuple inside union to union with compatible named tuple assigns named tuple inside union to union with compatible named tuple + codegens tuple nilable index (2) codegens tuple nilable index (2) + assigns named tuple to compatible named tuple assigns named tuple to compatible named tuple + gets keys at compile time (1) gets keys at compile time (1) + doesn't crash when overload doesn't match doesn't crash when overload doesn't match + gets keys at compile time (2) gets keys at compile time (2) + codegens union of tuple of float with tuple of tuple of float codegens union of tuple of float with tuple of tuple of float + assigns named tuple union to compatible named tuple assigns named tuple union to compatible named tuple + accesses T and creates instance from it accesses T and creates instance from it + codegens tuple index another order codegens tuple index another order + doesn't error if NamedTuple includes a non-generic module (#10380) doesn't error if NamedTuple includes a non-generic module (#10380) + gets size at compile time gets size at compile time + merges two named tuple types with same keys but different types (2) merges two named tuple types with same keys but different types (2) + codegens tuple index codegens tuple index +Crystal::Repl::Interpreter + tuple + interprets tuple metaclass range indexer interprets tuple metaclass range indexer + interprets tuple literal of different types (1) interprets tuple literal of different types (1) + discards tuple access discards tuple access + does tuple indexer on union does tuple indexer on union + unpacks tuple in block arguments unpacks tuple in block arguments + interprets tuple range indexer interprets tuple range indexer + discards tuple (#12383) discards tuple (#12383) + interprets tuple metaclass indexer interprets tuple metaclass indexer + interprets tuple literal and access by known index interprets tuple literal and access by known index + extends sign when doing to_i32 extends sign when doing to_i32 + interprets tuple literal of different types (2) interprets tuple literal of different types (2) + interprets tuple range indexer (2) interprets tuple range indexer (2) + interprets tuple self interprets tuple self +Crystal::Repl::Interpreter + class vars + interprets class var without initializer interprets class var without initializer + finds self in class var initializer (#12439) finds self in class var initializer (#12439) + interprets class var for virtual type interprets class var for virtual type + interprets class var with initializer interprets class var with initializer + reads class var initializer with union (#12633) reads class var initializer with union (#12633) + does class var initializer with union (#12633) does class var initializer with union (#12633) + interprets class var for virtual metaclass type interprets class var for virtual metaclass type +Compiler + runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename runs subcommand in preference to a filename + compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file compiles a file + treats all arguments post-filename as program arguments treats all arguments post-filename as program arguments + has a valid version has a valid version +Parser warnings + warns on missing space before colon + in anonymous block param type restriction in anonymous block param type restriction + in type declaration in type declaration + in return type restriction in return type restriction + in block param type restriction in block param type restriction + warns on suffix-less UInt64 literals > Int64::MAX warns on suffix-less UInt64 literals > Int64::MAX +Semantic: recursive struct check + errors on recursive struct inside module errors on recursive struct inside module + errors on recursive abstract struct through module (#11384) errors on recursive abstract struct through module (#11384) + errors on private recursive type errors on private recursive type + detects recursive generic struct through module (#4720) detects recursive generic struct through module (#4720) + detects recursive struct through module detects recursive struct through module + errors on mutually recursive struct errors on mutually recursive struct + errors on recursive struct through named tuple errors on recursive struct through named tuple + errors on recursive generic struct inside module errors on recursive generic struct inside module + errors on recursive struct through recursive alias (#4454) (#4455) errors on recursive struct through recursive alias (#4454) (#4455) + errors on recursive struct through tuple errors on recursive struct through tuple + detects recursive struct through inheritance (#3071) detects recursive struct through inheritance (#3071) + detects recursive generic struct through generic module (#4720) detects recursive generic struct through generic module (#4720) + errors on recursive struct errors on recursive struct Semantic: virtual - types method call of virtual type types method call of virtual type - reports undefined method in subclass of abstract class reports undefined method in subclass of abstract class - reports no matches for virtual type reports no matches for virtual type - types class and subclass as one type types class and subclass as one type - dispatches virtual method with overload dispatches virtual method with overload - types method call of virtual type with override types method call of virtual type with override + restricts with union and doesn't merge to super type restricts with union and doesn't merge to super type doesn't check methods on abstract classes doesn't check methods on abstract classes - doesn't check methods on abstract classes 2 doesn't check methods on abstract classes 2 + checks cover in every concrete subclass checks cover in every concrete subclass types class and two subclasses types class and two subclasses - types instance var as virtual when using type declaration and has subclasses types instance var as virtual when using type declaration and has subclasses - checks method in every concrete subclass but method in Object checks method in every concrete subclass but method in Object - dispatches virtual method dispatches virtual method - automatically does virtual for generic type if there are subclasses automatically does virtual for generic type if there are subclasses - finds overloads of union of virtual, class and nil finds overloads of union of virtual, class and nil + types method call of virtual type types method call of virtual type reports missing cover for subclass of abstract class reports missing cover for subclass of abstract class - doesn't check cover for subclasses doesn't check cover for subclasses - removes instance var from subclasses removes instance var from subclasses - checks cover in every concrete subclass checks cover in every concrete subclass - types two subclasses types two subclasses - types two classes without a shared virtual types two classes without a shared virtual works with restriction alpha works with restriction alpha - types inspect types inspect - uses virtual type as generic type if class is abstract uses virtual type as generic type if class is abstract - restricts with union and doesn't merge to super type restricts with union and doesn't merge to super type + reports undefined method in subclass of abstract class reports undefined method in subclass of abstract class + types two subclasses types two subclasses doesn't check cover for abstract classes doesn't check cover for abstract classes - finds overloads of union of virtual, class and nil with abstract class finds overloads of union of virtual, class and nil with abstract class + removes instance var from subclasses removes instance var from subclasses + automatically does virtual for generic type if there are subclasses automatically does virtual for generic type if there are subclasses uses virtual type as generic type if class is abstract even in union uses virtual type as generic type if class is abstract even in union checks cover in every concrete subclass 3 checks cover in every concrete subclass 3 + dispatches virtual method dispatches virtual method + types two classes without a shared virtual types two classes without a shared virtual + types class and subclass as one type types class and subclass as one type + reports no matches for virtual type reports no matches for virtual type + dispatches virtual method with overload dispatches virtual method with overload + types inspect types inspect + finds overloads of union of virtual, class and nil finds overloads of union of virtual, class and nil + uses virtual type as generic type if class is abstract uses virtual type as generic type if class is abstract + types instance var as virtual when using type declaration and has subclasses types instance var as virtual when using type declaration and has subclasses + types method call of virtual type with override types method call of virtual type with override + doesn't check methods on abstract classes 2 doesn't check methods on abstract classes 2 + doesn't check cover for subclasses doesn't check cover for subclasses checks cover in every concrete subclass 2 checks cover in every concrete subclass 2 -Crystal::JSONHierarchyPrinter - works works -Semantic: metaclass - types Reference metaclass types Reference metaclass - types Class class types Class class - types generic metaclass superclass types generic metaclass superclass - types Object class types Object class - types generic module metaclass types generic module metaclass - can't reopen as struct can't reopen as struct - can't reopen as module can't reopen as module - types Object and Class metaclasses types Object and Class metaclasses - subtyping relations between metaclasses - generic modules (1) generic modules (1) - generic classes (1) generic classes (1) - generic classes (2) generic classes (2) - generic modules (3) generic modules (3) - generic modules (2) generic modules (2) - generic classes (3) generic classes (3) - non-generic modules non-generic modules - non-generic classes non-generic classes - virtual metaclass type with virtual type (#12628) virtual metaclass type with virtual type (#12628) - types generic class metaclass types generic class metaclass - types generic instance metaclass superclass types generic instance metaclass superclass - types metaclass superclass types metaclass superclass -Code gen: struct - codegens passing pointerof(struct) to fun codegens passing pointerof(struct) to fun - automatically converts by invoking to_unsafe automatically converts by invoking to_unsafe - automatically converts numeric union type in struct field assignment automatically converts numeric union type in struct field assignment - sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc sets instance var to proc - codegens struct get inside struct codegens struct get inside struct - codegens struct access with -> and then . codegens struct access with -> and then . - codegens struct set inside struct codegens struct set inside struct - can access member of uninitialized struct behind type (#8774) can access member of uninitialized struct behind type (#8774) - codegens struct property setter via pointer codegens struct property setter via pointer - codegens set struct value with constant codegens set struct value with constant - builds struct setter with fun type (1) builds struct setter with fun type (1) - automatically converts numeric type in struct field assignment automatically converts numeric type in struct field assignment - automatically converts nil to pointer automatically converts nil to pointer - can access instance var from the outside (#1092) can access instance var from the outside (#1092) - passes struct to method (1) passes struct to method (1) - builds struct setter with fun type (2) builds struct setter with fun type (2) - does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s - codegens struct property default value codegens struct property default value - codegens struct property setter codegens struct property setter - codegens struct property setter via pointer codegens struct property setter via pointer - codegens pointer malloc of struct codegens pointer malloc of struct - codegens union inside struct codegens union inside struct - passes struct to method (2) passes struct to method (2) - allows using named arguments for new allows using named arguments for new - codegens assign struct to union codegens assign struct to union - yields struct via -> yields struct via -> + checks method in every concrete subclass but method in Object checks method in every concrete subclass but method in Object + finds overloads of union of virtual, class and nil with abstract class finds overloads of union of virtual, class and nil with abstract class +Semantic: def + reports no overload matches 2 reports no overload matches 2 + errors if return type doesn't match on class method errors if return type doesn't match on class method + errors when default value is incompatible with non-type restriction errors when default value is incompatible with non-type restriction + types a call with an argument uses a new scope types a call with an argument uses a new scope + is ok if returns Int32? with explicit return is ok if returns Int32? with explicit return + types a call with a float types a call with a float + types empty body def types empty body def + allows recursion allows recursion + types getchar with Char types getchar with Char + defines class method defines class method + uses free variable and doesn't conflict with top-level type uses free variable and doesn't conflict with top-level type + lookups methods in super modules lookups methods in super modules + errors if declares def inside if errors if declares def inside if + clones regex literal value (#2384) clones regex literal value (#2384) + says can only defined def on types and self says can only defined def on types and self + types call with union argument types call with union argument + errors if return type doesn't match errors if return type doesn't match + gives correct error for wrong number of arguments for program call inside type (2) (#1024) gives correct error for wrong number of arguments for program call inside type (2) (#1024) + assigns def owner assigns def owner + uses free variable as block return type uses free variable as block return type + types call with global scope types call with global scope + types simple recursion types simple recursion + defines class method with self defines class method with self + allows recursion with arg allows recursion with arg + gives correct error for methods in Class gives correct error for methods in Class + types a call with a double types a call with a double + uses free variable with metaclass and default value uses free variable with metaclass and default value + errors when default value is incompatible with type restriction errors when default value is incompatible with type restriction + uses free variable with metaclass uses free variable with metaclass + types a call with an argument types a call with an argument + calls with default argument calls with default argument + points error at name (#6937) points error at name (#6937) + gives correct error for methods in Class (2) gives correct error for methods in Class (2) + types a call with an int types a call with an int + fixes bug #165 fixes bug #165 + says compile-time type on error says compile-time type on error + errors if trying to declare method on generic class instance errors if trying to declare method on generic class instance + errors when calling two functions with nil type errors when calling two functions with nil type + types putchar with Char types putchar with Char + can't use self in toplevel method can't use self in toplevel method + shows free variables if no overload matches shows free variables if no overload matches + accesses free var of default argument (#1101) accesses free var of default argument (#1101) + reports no block given reports no block given + types mutual recursion types mutual recursion + reports block given reports block given + reports undefined method reports undefined method + types simple recursion 2 types simple recursion 2 + uses free variable uses free variable + types a call with an argument types a call with an argument + reports no overload matches reports no overload matches + doesn't find type in namespace through free var doesn't find type in namespace through free var + types mutual infinite recursion types mutual infinite recursion + gives correct error for wrong number of arguments for program call inside type (#1024) gives correct error for wrong number of arguments for program call inside type (#1024) + errors if return type doesn't match on instance method errors if return type doesn't match on instance method + do not use body for the def type do not use body for the def type +Code gen: not + doesn't crash doesn't crash + codegens not nil codegens not nil + codegens not nilable type (false) codegens not nilable type (false) + codegens not with inlinable value (#6451) codegens not with inlinable value (#6451) + codegens not nilable type (true) codegens not nilable type (true) + codegens not false codegens not false + codegens not true codegens not true + codegens not pointer (true) codegens not pointer (true) + codegens not number codegens not number + codegens not pointer (false) codegens not pointer (false) +Crystal::Playground::AgentInstrumentorTransformer + instrument blocks and single yields instrument blocks and single yields + instrument case statement instrument case statement + instrument if statement instrument if statement + instrument instance variable and class variables reads and writes instrument instance variable and class variables reads and writes + instrument puts with args instrument puts with args + instrument ivar with obj instrument ivar with obj + instrument literals with expression names instrument literals with expression names + instrument assignments in the rhs instrument assignments in the rhs + instrument nested class defs instrument nested class defs + instrument single variables expressions instrument single variables expressions + instrument chained comparisons (#4663) instrument chained comparisons (#4663) + instrument string interpolations instrument string interpolations + instrument multi assignments in the rhs instrument multi assignments in the rhs + instrument exceptions instrument exceptions + instrument single statement var def instrument single statement var def + instrument is_a? expressions instrument is_a? expressions + instrument literals instrument literals + do not instrument class/module declared macro do not instrument class/module declared macro + instrument unless statement instrument unless statement + instrument binary expressions instrument binary expressions + do not instrument macro calls in class do not instrument macro calls in class + instrument while statement instrument while statement + instrument blocks and but non multi yields instrument blocks and but non multi yields + do not instrument records class do not instrument records class + instrument class defs instrument class defs + instrument inside modules instrument inside modules + do not instrument class initializing arguments do not instrument class initializing arguments + do not instrument constants assignments do not instrument constants assignments + do not instrument top level macro calls do not instrument top level macro calls + instrument returns inside def instrument returns inside def + instrument print with args instrument print with args + instrument unary expressions instrument unary expressions + instrument single statement def instrument single statement def + instrument not expressions instrument not expressions + instrument typeof instrument typeof + instrument nested blocks unless in same line instrument nested blocks unless in same line + allow visibility modifiers allow visibility modifiers + instrument multi statement def instrument multi statement def +Semantic: extern struct + declares extern union with no constructor declares extern union with no constructor + overrides getter overrides getter + can be passed to C fun can be passed to C fun + declares extern struct with no constructor declares extern struct with no constructor + can use extern struct in lib can use extern struct in lib + declares with constructor declares with constructor + errors if using non-primitive for field type via module errors if using non-primitive for field type via module + errors if using non-primitive for field type errors if using non-primitive for field type + can new with named args can new with named args + can include module can include module + errors if using non-primitive type in constructor errors if using non-primitive type in constructor +cleanup + strip tuple elements after unreachable element strip tuple elements after unreachable element + errors if assigning var to itself errors if assigning var to itself + strip named-tuple elements after unreachable element strip named-tuple elements after unreachable element + errors if assigning instance var to itself errors if assigning instance var to itself +file_exists? + with relative path + reads file (doesn't exist) reads file (doesn't exist) + reads file (exists) reads file (exists) + with absolute path + returns false if file doesn't exist returns false if file doesn't exist + returns true if file exists returns true if file exists +Code gen: union type + assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union assigns union to union + codegens union type as return value codegens union type as return value + codegens union type for instance var codegens union type for instance var + codegens union type when no obj codegens union type when no obj + assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 assigns union to larger union when source is nilable 2 + codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s codegens union to_s + assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 assigns union to larger union when source is nilable 1 + codegens union type when obj is not union but arg is codegens union type when obj is not union but arg is + dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable dispatch call to object method on nilable + assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union assigns union to larger union + respects union payload alignment when upcasting Bool (#14898) respects union payload alignment when upcasting Bool (#14898) + codegens if with same nested union codegens if with same nested union + codegens union type when obj is union and no args codegens union type when obj is union and no args + codegens union type when no obj and restrictions codegens union type when no obj and restrictions + sorts restrictions when there are unions sorts restrictions when there are unions + codegens union type when obj is union and arg is union codegens union type when obj is union and arg is union + provides T as a tuple literal provides T as a tuple literal + codegens union type when obj union but arg is not codegens union type when obj union but arg is not +Semantic: uninitialized + disallows declaring var of type Number disallows declaring var of type Number + declares as uninitialized declares as uninitialized + can uninitialize variable outside initialize, generic (#2828) can uninitialize variable outside initialize, generic (#2828) + errors if declares var and then assigns other type errors if declares var and then assigns other type + disallows declaring var of type Class disallows declaring var of type Class + disallows declaring var of type Float disallows declaring var of type Float + disallows declaring var of type Enum disallows declaring var of type Enum + disallows declaring var of type Reference disallows declaring var of type Reference + disallows declaring var of type Struct disallows declaring var of type Struct + errors if declaring variable multiple times with different types (#917) errors if declaring variable multiple times with different types (#917) + errors if declaring generic type without type vars (with class var) errors if declaring generic type without type vars (with class var) + can use uninitialized with class type (#2940) can use uninitialized with class type (#2940) + disallows declaring var of type Int disallows declaring var of type Int + works with uninitialized NoReturn (#3314) works with uninitialized NoReturn (#3314) + uses virtual type for uninitialized (#8216) uses virtual type for uninitialized (#8216) + declares an instance variable in initialize as uninitialized declares an instance variable in initialize as uninitialized + declares as uninitialized and reads it declares as uninitialized and reads it + has type (#3641) has type (#3641) + can uninitialize variable outside initialize (#2828) can uninitialize variable outside initialize (#2828) + disallows declaring var of type Object disallows declaring var of type Object + disallows declaring var of type Value disallows declaring var of type Value + errors if declaring generic type without type vars (with instance var) errors if declaring generic type without type vars (with instance var) +Crystal::Repl::Interpreter + autocast + autocasts float32 var to float64 (#12560) autocasts float32 var to float64 (#12560) + autocasts symbol to enum in ivar initializer (#12216) autocasts symbol to enum in ivar initializer (#12216) + autocasts integer var to float (#12560) autocasts integer var to float (#12560) + autocasts int in multidispatch autocasts int in multidispatch + autocasts number literal to integer autocasts number literal to integer + autocasts symbol to enum in multidispatch (#11782) autocasts symbol to enum in multidispatch (#11782) + autocasts symbol to enum autocasts symbol to enum + autocasts number literal to float autocasts number literal to float + autocasts integer var to integer (#12560) autocasts integer var to integer (#12560) +Semantic: ssa + types if with return in else with assign types if with return in else with assign + types if with return in then with assign types if with return in then with assign + types a var inside an if without previous definition types a var inside an if without previous definition + types if with break in then types if with break in then + types block with break types block with break + types a var inside an if with previous definition types a var inside an if with previous definition + types while with break types while with break + types if with return in then types if with return in then + types a var that is declared in a while condition types a var that is declared in a while condition + types block with break doesn't infect initial vars types block with break doesn't infect initial vars + types a var with an if with nested if types a var with an if with nested if + doesn't change type to nilable inside if doesn't change type to nilable inside if + doesn't error if same variable is declared in multiple typeofs doesn't error if same variable is declared in multiple typeofs + types a var after begin ensure as having last type types a var after begin ensure as having last type + types a var inside an if without definition in else types a var inside an if without definition in else + types a var that is re-assigned in a while condition types a var that is re-assigned in a while condition + types re-assign inside while (bug) types re-assign inside while (bug) + doesn't error if same variable is used in multiple arguments of same typeof doesn't error if same variable is used in multiple arguments of same typeof + types if with unreachable in then types if with unreachable in then + types if with restricted type in then types if with restricted type in then + types a var that is re-assigned in a while and used in condition types a var that is re-assigned in a while and used in condition + types block with next types block with next + types a var inside an if without change in else types a var inside an if without change in else + types a var that is declared in a while with out types a var that is declared in a while with out + types if with return in both branches types if with return in both branches + types a var that is declared in a while condition with break after re-assignment types a var that is declared in a while condition with break after re-assignment + types a var after begin ensure as having last type (2) types a var after begin ensure as having last type (2) + types a var with an if but without change types a var with an if but without change + types while with next types while with next + types if with return in else types if with return in else + preserves type filters after block (bug) preserves type filters after block (bug) + types a var inside an if without change in then types a var inside an if without change in then + types if with next in then types if with next in then + types while with break with new var types while with break with new var + types a var that is re-assigned in a while in next and used in condition types a var that is re-assigned in a while in next and used in condition + types if with restricted type in else types if with restricted type in else + types a var that is re-assigned in a while types a var that is re-assigned in a while + types a var that is re-assigned in a block types a var that is re-assigned in a block + types re-assign inside if (bug) types re-assign inside if (bug) + types a var inside an if without definition in then types a var inside an if without definition in then + types while with break doesn't infect initial vars types while with break doesn't infect initial vars + types a var that is declared in a while condition with break before re-assignment types a var that is declared in a while condition with break before re-assignment + types if/else with var (bug) types if/else with var (bug) + types a var that is declared in a while types a var that is declared in a while + types a redefined variable types a redefined variable + errors if accessing variable declared inside typeof errors if accessing variable declared inside typeof +Normalize: def + expands with splat and zero expands with splat and zero + expands a def with splat and double splat expands a def with splat and double splat + expands with named argument and yield expands with named argument and yield + expands a def on request with default arguments that yields (external names) expands a def on request with default arguments that yields (external names) + expands arg with default value after splat expands arg with default value after splat + gives correct body location with + default arg with restriction, without body default arg with restriction, without body + default arg, with body default arg, with body + block instance var arg, with body block instance var arg, with body + block instance var arg, without body block instance var arg, without body + default arg, without body default arg, without body + default arg with restriction, with body default arg with restriction, with body + splat arg, without body splat arg, without body + splat arg, with body splat arg, with body + expands a def with external names (2) expands a def with external names (2) + expands a def with double splat and two named args expands a def with double splat and two named args + expands a def on request with default arguments expands a def on request with default arguments + expands with more named arg which come in the correct order expands with more named arg which come in the correct order + expands a new def with double splat and two named args and regular args expands a new def with double splat and two named args and regular args + expands with splat and default argument expands with splat and default argument + expands with magic constant specifying one when all are magic expands with magic constant specifying one when all are magic + expands a def on request with default arguments (external names) expands a def on request with default arguments (external names) + expands with two named argument and one not expands with two named argument and one not + expands a def on request with default arguments and type restrictions expands a def on request with default arguments and type restrictions + expands a def with double splat and no args expands a def with double splat and no args + expands with one named arg that is the only one (1) expands with one named arg that is the only one (1) + expands def with reserved external name (#6559) expands def with reserved external name (#6559) + expands with splat with one arg before expands with splat with one arg before + expands with magic constant with named arg expands with magic constant with named arg + expands with magic constant expands with magic constant + expands with one named arg that is the only one (2) expands with one named arg that is the only one (2) + expands with two named argument expands with two named argument + expands with magic constant specifying one when not all are magic expands with magic constant specifying one when not all are magic + expands default value after splat index expands default value after splat index + expands with named argument expands with named argument + expands a def on request with default arguments and type restrictions (2) expands a def on request with default arguments and type restrictions (2) + expands a def with external names (1) expands a def with external names (1) + expands a def with double splat and two named args and regular args expands a def with double splat and two named args and regular args + expands a def on request with default arguments that yields expands a def on request with default arguments that yields + uses bare * uses bare * + expands a def on request with default arguments (2) expands a def on request with default arguments (2) + expands with splat expands with splat + expands with magic constant with named arg with yield expands with magic constant with named arg with yield + expands a def on request with default arguments that yields (2) expands a def on request with default arguments that yields (2) +Codegen: is_a? + codegens is_a? casts union to nilable codegens is_a? casts union to nilable + codegens is_a? on right side of and codegens is_a? on right side of and + doesn't consider generic type to be a generic type of a recursive alias (#3524) doesn't consider generic type to be a generic type of a recursive alias (#3524) + doesn't error if result is discarded (#14113) doesn't error if result is discarded (#14113) + restricts metaclass against virtual metaclass type restricts metaclass against virtual metaclass type + evaluates method on filtered union type 2 evaluates method on filtered union type 2 + restricts type in else but lazily restricts type in else but lazily + codegens is_a? with nilable gives false because other type 1 codegens is_a? with nilable gives false because other type 1 + works with inherited generic class against an instantiation works with inherited generic class against an instantiation + evaluate method on filtered type evaluate method on filtered type + codegens is_a? with virtual and module codegens is_a? with virtual and module + does is_a? with generic class metaclass does is_a? with generic class metaclass + doesn't work with inherited generic class against an instantiation (2) doesn't work with inherited generic class against an instantiation (2) + does is_a?(generic type) for nested generic inheritance, through upcast (1) does is_a?(generic type) for nested generic inheritance, through upcast (1) + codegens is_a? from nilable reference union type to nil codegens is_a? from nilable reference union type to nil + restricts virtual metaclass against virtual metaclass type restricts virtual metaclass against virtual metaclass type + evaluates method on filtered union type evaluates method on filtered union type + codegens is_a? false for simple type codegens is_a? false for simple type + doesn't skip assignment when used in combination with .is_a? and && (#1121) doesn't skip assignment when used in combination with .is_a? and && (#1121) + doesn't type merge (1) (#548) doesn't type merge (1) (#548) + transforms else if condition is always falsey transforms else if condition is always falsey + does is_a? with more strict virtual type does is_a? with more strict virtual type + does is_a? with union type as Union(X, Y), don't resolve to virtual type (#10244) does is_a? with union type as Union(X, Y), don't resolve to virtual type (#10244) + codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used codegens when is_a? is always false but properties are used + codegens is_a? with union gives true codegens is_a? with union gives true + passes is_a? with generic module type on virtual type (#10302) passes is_a? with generic module type on virtual type (#10302) + codegens is_a? true for simple type codegens is_a? true for simple type + does is_a? for virtual generic instance type against generic does is_a? for virtual generic instance type against generic + restricts union with union restricts union with union + codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true codegens is_a? with a Const does comparison and gives true + says true for Class.is_a?(Class.class) (#4374) says true for Class.is_a?(Class.class) (#4374) + doesn't type merge (2) (#548) doesn't type merge (2) (#548) + visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) visits 1.to_s twice, may trigger enclosing_call (#4364) + does is_a? with && and true condition does is_a? with && and true condition + restricts union metaclass to metaclass (#12295) restricts union metaclass to metaclass (#12295) + codegens untyped var (#4009) codegens untyped var (#4009) + doesn't skip assignment when used in combination with .is_a? (false case) (#1121) doesn't skip assignment when used in combination with .is_a? (false case) (#1121) + doesn't skip assignment when used in combination with .is_a? (true case, else) (#1121) doesn't skip assignment when used in combination with .is_a? (true case, else) (#1121) + works with inherited generic class against an instantiation (3) works with inherited generic class against an instantiation (3) + does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) does is_a? for generic type against generic class instance type (#12304) + codegens is_a? with nilable gives false because no type codegens is_a? with nilable gives false because no type + evaluate method on filtered type nilable type not-nil evaluate method on filtered type nilable type not-nil + codegens is_a? with nilable gives false because no type codegens is_a? with nilable gives false because no type + codegens is_a? with virtual codegens is_a? with virtual + restricts simple type with union restricts simple type with union + does is_a?(generic type) for nested generic inheritance, through upcast (2) does is_a?(generic type) for nested generic inheritance, through upcast (2) + codegens is_a? with union gives false codegens is_a? with union gives false + virtual metaclass type is not virtual instance type (#12628) virtual metaclass type is not virtual instance type (#12628) + codegens is_a? with union gives true codegens is_a? with union gives true + does is_a? with union type, don't resolve to virtual type (#10244) does is_a? with union type, don't resolve to virtual type (#10244) + codegens is_a? with nilable gives false because other type 2 codegens is_a? with nilable gives false because other type 2 + codegens is_a? casts union to nilable in method codegens is_a? casts union to nilable in method + doesn't skip assignment when used in combination with .is_a? (true case, then) (#1121) doesn't skip assignment when used in combination with .is_a? (true case, then) (#1121) + says false for value.is_a?(Class) says false for value.is_a?(Class) + evaluate method on filtered type nilable type nil evaluate method on filtered type nilable type nil + evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 evaluates method on filtered union type 3 + does is_a?(generic type) for nested generic inheritance (2) does is_a?(generic type) for nested generic inheritance (2) + codegens is_a? with nilable gives true codegens is_a? with nilable gives true + codegens is_a? from virtual type to module codegens is_a? from virtual type to module + does is_a?/responds_to? twice (#1451) does is_a?/responds_to? twice (#1451) + codegens is_a? from nilable reference union type to type codegens is_a? from nilable reference union type to type + says false for GenericChild(Base).is_a?(GenericBase(Child)) (#1294) says false for GenericChild(Base).is_a?(GenericBase(Child)) (#1294) + does is_a? for union of module and type does is_a? for union of module and type + codegens is_a? with virtual and nil codegens is_a? with virtual and nil + codegens is_a? with union gives false codegens is_a? with union gives false + gives false if generic type doesn't match exactly gives false if generic type doesn't match exactly + does is_a?(generic type) for nested generic inheritance (1) (#9660) does is_a?(generic type) for nested generic inheritance (1) (#9660) + codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false codegens is_a? with a Const does comparison and gives false + transforms then if condition is always truthy transforms then if condition is always truthy + resets truthy state after visiting nodes (bug) resets truthy state after visiting nodes (bug) + says true for Class.is_a?(Class.class.class) (#4374) says true for Class.is_a?(Class.class.class) (#4374) +Crystal::Repl::Interpreter + calls + does ReadInstanceVar with wants_struct_pointer does ReadInstanceVar with wants_struct_pointer + does call with struct as obj (2) does call with struct as obj (2) + mutates through inlined instance var with receiver mutates through inlined instance var with receiver + inlines call that returns self inlines call that returns self + puts struct pointer after tuple indexer puts struct pointer after tuple indexer + inlines method that just reads an instance var, but produces side effects of args inlines method that just reads an instance var, but produces side effects of args + inlines method that just reads an instance var inlines method that just reads an instance var + does call on instance var that's a struct, from a class does call on instance var that's a struct, from a class + inlines call that returns self (2) inlines call that returns self (2) + mutates through pointer (3) mutates through pointer (3) + mutates through inlined instance var without receiver mutates through inlined instance var without receiver + mutates through pointer (1) mutates through pointer (1) + calls a top-level method without arguments and no local vars calls a top-level method without arguments and no local vars + interprets call with default values interprets call with default values + discards call with struct as obj discards call with struct as obj + does Assign instance var with wants_struct_pointer does Assign instance var with wants_struct_pointer + does Assign var with wants_struct_pointer does Assign var with wants_struct_pointer + does call with struct as obj does call with struct as obj + mutates call argument mutates call argument + interprets implicit self call for pointer interprets implicit self call for pointer + calls a top-level method with two arguments calls a top-level method with two arguments + does call on ivar that's a struct, takes a pointer to instance var, inside if does call on ivar that's a struct, takes a pointer to instance var, inside if + does call on read instance var that's a struct, takes a pointer to instance var does call on read instance var that's a struct, takes a pointer to instance var + mutates through read instance var mutates through read instance var + calls a top-level method without arguments but with local vars calls a top-level method without arguments but with local vars + interprets call with named arguments interprets call with named arguments + interprets call with if interprets call with if + does call on self that's a struct, takes a pointer to instance var, inside if does call on self that's a struct, takes a pointer to instance var, inside if + does call on instance var that's a struct, from a struct does call on instance var that's a struct, from a struct + does call on constant that's a struct, takes a pointer to instance var, inside if does call on constant that's a struct, takes a pointer to instance var, inside if + does Assign class var with wants_struct_pointer does Assign class var with wants_struct_pointer + mutates through pointer (2) mutates through pointer (2) + does call on var that's a struct, takes a pointer to instance var, inside if does call on var that's a struct, takes a pointer to instance var, inside if + does call on constant that's a struct, takes a pointer to instance var does call on constant that's a struct, takes a pointer to instance var + inlines method that just reads an instance var (2) inlines method that just reads an instance var (2) + does call on Pointer#value that's a struct, takes a pointer to instance var does call on Pointer#value that's a struct, takes a pointer to instance var + interprets self for primitive types interprets self for primitive types + interprets explicit self call for primitive types interprets explicit self call for primitive types +Code gen: lib + uses static array in lib extern (#5688) uses static array in lib extern (#5688) + passes nil to varargs (#1570) passes nil to varargs (#1570) + call to void function call to void function + refers to lib type (#960) refers to lib type (#960) + casts C fun to Crystal proc when accessing instance var (#2515) casts C fun to Crystal proc when accessing instance var (#2515) + doesn't crash with nil and varargs (#4414) doesn't crash with nil and varargs (#4414) + can use enum as fun return can use enum as fun return + can use enum as fun argument can use enum as fun argument + doesn't crash when casting -1 to UInt32 (#3594) doesn't crash when casting -1 to UInt32 (#3594) + allows setting/getting external variable as function pointer allows setting/getting external variable as function pointer + allows passing type to LibC if it has a converter with to_unsafe (bug) allows passing type to LibC if it has a converter with to_unsafe (bug) + get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) get fun field from union (#672) + allows invoking out with underscore allows invoking out with underscore + get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) get fun field from struct (#672) + allows passing type to LibC if it has a converter with to_unsafe allows passing type to LibC if it has a converter with to_unsafe + can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return can use tuple as fun return + codegens lib var set and get codegens lib var set and get + passes int as another float type in literal passes int as another float type in literal ASTNode#to_s - does to_s of "foo(\"bar baz\": 2)" does to_s of "foo(\"bar baz\": 2)" - does to_s of "&+1" does to_s of "&+1" - does to_s of "foo x: 1, y: 2, &.bar" does to_s of "foo x: 1, y: 2, &.bar" - does to_s of "`\#{1}\\n\\0`" does to_s of "`\#{1}\\n\\0`" + does to_s of "lib Foo\n struct Foo\n a : Void\n b : Void\n end\nend" does to_s of "lib Foo\n struct Foo\n a : Void\n b : Void\n end\nend" + does to_s of "offsetof(Foo, @bar)" does to_s of "offsetof(Foo, @bar)" + does to_s of "foo { |i| i.bar { i } }" does to_s of "foo { |i| i.bar { i } }" + does to_s of "lib Foo\n A = Pointer(Void).new(0)\n struct B\n x : Void*\n y : Int[1]\n end\n fun c(Void*) : Char[2]*\nend" does to_s of "lib Foo\n A = Pointer(Void).new(0)\n struct B\n x : Void*\n y : Int[1]\n end\n fun c(Void*) : Char[2]*\nend" + does to_s of "lib Foo\n FOO = 0\nend" does to_s of "lib Foo\n FOO = 0\nend" + does to_s of "def foo(& : ->)\nend" does to_s of "def foo(& : ->)\nend" does to_s of "asm(\"bl trap\" :::: \"unwind\")" does to_s of "asm(\"bl trap\" :::: \"unwind\")" - does to_s of "->(x : Int32, y : Bool) : Char do\n 'a'\nend" does to_s of "->(x : Int32, y : Bool) : Char do\n 'a'\nend" - does to_s of x = (1 -2 -) does to_s of x = (1 -2 -) - does to_s of "def foo(**args)\nend" does to_s of "def foo(**args)\nend" - does to_s of "%(\"\#{foo}\")" does to_s of "%(\"\#{foo}\")" - does to_s of "1[2, x: 3, &.foo]" does to_s of "1[2, x: 3, &.foo]" + does to_s of "# doc\ndef foo\nend" does to_s of "# doc\ndef foo\nend" + does to_s of "macro foo(x, @[Foo] *y)\nend" does to_s of "macro foo(x, @[Foo] *y)\nend" + does to_s of "\"\\e\\0\\\"\"" does to_s of "\"\\e\\0\\\"\"" + does to_s of "(1 + 2).as(Int32)" does to_s of "(1 + 2).as(Int32)" + does to_s of "foo do |k, v|\n k.bar(1, 2, 3)\nend" does to_s of "foo do |k, v|\n k.bar(1, 2, 3)\nend" + does to_s of "fun foo\nend" does to_s of "fun foo\nend" + does to_s of "\"\#{1}\\0\"" does to_s of "\"\#{1}\\0\"" + does to_s of "enum Foo\n A = 0\n B\nend" does to_s of "enum Foo\n A = 0\n B\nend" + does to_s of "&-1" does to_s of "&-1" + does to_s of "([] of T).foo" does to_s of "([] of T).foo" + does to_s of "@[Foo(1, 2, a: 1, b: 2)]" does to_s of "@[Foo(1, 2, a: 1, b: 2)]" + does to_s of "1 && (a = 2)" does to_s of "1 && (a = 2)" + does to_s of "foo(x : Foo((T -> U)))" does to_s of "foo(x : Foo((T -> U)))" + does to_s of "fun foo(a : Void, b : Void, ...) : Void\nend" does to_s of "fun foo(a : Void, b : Void, ...) : Void\nend" does to_s of "/ /" does to_s of "/ /" - does to_s of "foo(1, (2 + 3), bar: (4 + 5))" does to_s of "foo(1, (2 + 3), bar: (4 + 5))" - does to_s of "foo : A | (B -> C)" does to_s of "foo : A | (B -> C)" - does to_s of "(~1).foo" does to_s of "(~1).foo" - does to_s of "def foo(x : X, @[Foo] y : Y) forall X, Y\nend" does to_s of "def foo(x : X, @[Foo] y : Y) forall X, Y\nend" - does to_s of "def foo(x : X, y : Y) forall X, Y\nend" does to_s of "def foo(x : X, y : Y) forall X, Y\nend" - does to_s of "/\#{1 / 2}/" does to_s of "/\#{1 / 2}/" - does to_s of "{% if foo %}\n foo_then\n{% end %}" does to_s of "{% if foo %}\n foo_then\n{% end %}" - does to_s of "def foo(@[Foo] x : T = 1)\nend" does to_s of "def foo(@[Foo] x : T = 1)\nend" - does to_s of "alias Foo = Void" does to_s of "alias Foo = Void" - does to_s of "foo[x : (T -> U) -> V, W] = 1" does to_s of "foo[x : (T -> U) -> V, W] = 1" - does to_s of "a.as?(Int32)" does to_s of "a.as?(Int32)" - does to_s of "macro foo(@[Foo] x, @[Foo] *y)\nend" does to_s of "macro foo(@[Foo] x, @[Foo] *y)\nend" - does to_s of "%r{\#{1}\\/\\0}" does to_s of "%r{\#{1}\\/\\0}" - does to_s of "{% for foo in bar %}\n {{ if true\n foo\n bar\nend }}\n{% end %}" does to_s of "{% for foo in bar %}\n {{ if true\n foo\n bar\nend }}\n{% end %}" - does to_s of "他.说 = \"你好\"" does to_s of "他.说 = \"你好\"" - does to_s of "1 & 2 & (3 | 4)" does to_s of "1 & 2 & (3 | 4)" - does to_s of "macro foo(x)\n yield\nend" does to_s of "macro foo(x)\n yield\nend" - does to_s of "_foo.bar" does to_s of "_foo.bar" - does to_s of "macro foo(@[Foo] **args)\nend" does to_s of "macro foo(@[Foo] **args)\nend" - does to_s of "macro foo\n 123\nend" does to_s of "macro foo\n 123\nend" does to_s of "lib Foo\nend" does to_s of "lib Foo\nend" + does to_s of "def foo(x : (T -> U) | V)\nend" does to_s of "def foo(x : (T -> U) | V)\nend" + does to_s of "`\#{1}\\n\\0`" does to_s of "`\#{1}\\n\\0`" + does to_s of "enum A : B\nend" does to_s of "enum A : B\nend" + does to_s of "if (1 + 2\n3)\n 4\nend" does to_s of "if (1 + 2\n3)\n 4\nend" + does to_s of "{ {1, 2, 3} }" does to_s of "{ {1, 2, 3} }" + does to_s of "def foo(x, @[Foo] **args)\nend" does to_s of "def foo(x, @[Foo] **args)\nend" + does to_s of "あ.い, う.え.お = 1, 2" does to_s of "あ.い, う.え.お = 1, 2" + does to_s of "{% foo %}" does to_s of "{% foo %}" + does to_s of "select\nwhen foo\n select\n when bar\n 1\n else\n 2\n end\nelse\n select\n when baz\n 3\n else\n 4\n end\nend" does to_s of "select\nwhen foo\n select\n when bar\n 1\n else\n 2\n end\nelse\n select\n when baz\n 3\n else\n 4\n end\nend" + does to_s of "case 1\nwhen .[](2)\n 3\nwhen .[]=(4)\n 5\nend" does to_s of "case 1\nwhen .[](2)\n 3\nwhen .[]=(4)\n 5\nend" + does to_s of "macro foo\n{% @type %}\nend" does to_s of "macro foo\n{% @type %}\nend" + does to_s of "macro foo\n\\{%@type %}\nend" does to_s of "macro foo\n\\{%@type %}\nend" + does to_s of "(1 <= 2) <= 3" does to_s of "(1 <= 2) <= 3" + does to_s of "foo.*" does to_s of "foo.*" + does to_s of "macro foo(x)\n yield\nend" does to_s of "macro foo(x)\n yield\nend" + does to_s of "1_f64" does to_s of "1_f64" + does to_s of "def foo(x : (T -> U) -> V, *args : (T -> U) -> V, y : (T -> U) -> V, **opts : (T -> U) -> V, & : (T -> U) -> V) : ((T -> U) -> V)\nend" does to_s of "def foo(x : (T -> U) -> V, *args : (T -> U) -> V, y : (T -> U) -> V, **opts : (T -> U) -> V, & : (T -> U) -> V) : ((T -> U) -> V)\nend" + does to_s of "begin\n ()\nend" does to_s of "begin\n ()\nend" does to_s of "%r()imx" does to_s of "%r()imx" - does to_s of "class Foo\n # doc\n def foo\n end\nend" does to_s of "class Foo\n # doc\n def foo\n end\nend" - does to_s of "return begin\n 1\n 2\nend" does to_s of "return begin\n 1\n 2\nend" + does to_s of "foo { |(x, y)| x }" does to_s of "foo { |(x, y)| x }" + does to_s of "%r{\\/\\0}" does to_s of "%r{\\/\\0}" + does to_s of "->(x : Int32, y : Bool) : Char do\n 'a'\nend" does to_s of "->(x : Int32, y : Bool) : Char do\n 'a'\nend" + does to_s of "1[2, x: 3, &.foo]" does to_s of "1[2, x: 3, &.foo]" + does to_s of "yield(1)" does to_s of "yield(1)" + does to_s of "{% if foo %}\n foo_then\n{% else %}\n foo_else\n{% end %}" does to_s of "{% if foo %}\n foo_then\n{% else %}\n foo_else\n{% end %}" + does to_s of "1.~(2)" does to_s of "1.~(2)" + does to_s of "type(Foo = Void)" does to_s of "type(Foo = Void)" + does to_s of "{% for foo in bar %}\n {{ foo }}\n{% end %}" does to_s of "{% for foo in bar %}\n {{ foo }}\n{% end %}" + does to_s of "foo &.bar(1, 2, 3)" does to_s of "foo &.bar(1, 2, 3)" does to_s of "1.0" does to_s of "1.0" - does to_s of "begin\n ()\nend" does to_s of "begin\n ()\nend" - does to_s of "foo { |(x, (y, z))| x }" does to_s of "foo { |(x, (y, z))| x }" - does to_s of "->::foo(Int32, String)" does to_s of "->::foo(Int32, String)" + does to_s of "1.+(&block)" does to_s of "1.+(&block)" + does to_s of "foo(bar)" does to_s of "foo(bar)" + does to_s of "lib Foo::Bar\nend" does to_s of "lib Foo::Bar\nend" + does to_s of "foo[x, y, a: 1, b: 2] = z" does to_s of "foo[x, y, a: 1, b: 2] = z" + does to_s of "begin\n (@x = x).is_a?(Foo)\nend" does to_s of "begin\n (@x = x).is_a?(Foo)\nend" + does to_s of "(~1).foo" does to_s of "(~1).foo" + does to_s of "@foo.bar" does to_s of "@foo.bar" does to_s of "!(1 < 2)" does to_s of "!(1 < 2)" - does to_s of "def foo(x : (T -> U).class)\nend" does to_s of "def foo(x : (T -> U).class)\nend" + does to_s of "foo(\"bar baz\": 2)" does to_s of "foo(\"bar baz\": 2)" + does to_s of "class Foo\n private def bar\n end\nend" does to_s of "class Foo\n private def bar\n end\nend" + does to_s of "begin\n (1)\n 2\nrescue\nend" does to_s of "begin\n (1)\n 2\nrescue\nend" + does to_s of "macro foo\n %bar{1, x} = 1\nend" does to_s of "macro foo\n %bar{1, x} = 1\nend" + does to_s of "%r( )" does to_s of "%r( )" + does to_s of "Foo()" does to_s of "Foo()" + does to_s of "asm(\"nop\" ::: \"e\" : \"volatile\")" does to_s of "asm(\"nop\" ::: \"e\" : \"volatile\")" + does to_s of "macro foo(*, var)\nend" does to_s of "macro foo(*, var)\nend" + does to_s of "1.+(a: 2)" does to_s of "1.+(a: 2)" + does to_s of "他.说 = \"你好\"" does to_s of "他.说 = \"你好\"" + does to_s of "1[2, x: 3, &.foo]?" does to_s of "1[2, x: 3, &.foo]?" + does to_s of "-> : Int32 do\nend" does to_s of "-> : Int32 do\nend" + does to_s of "1.as(Int32)" does to_s of "1.as(Int32)" does to_s of "if 1\n begin\n 2\n end\nelse\n begin\n 3\n end\nend" does to_s of "if 1\n begin\n 2\n end\nelse\n begin\n 3\n end\nend" - does to_s of "/hello world/" does to_s of "/hello world/" - does to_s of "fun foo\nend" does to_s of "fun foo\nend" - does to_s of "\"\#{1}\\0\"" does to_s of "\"\#{1}\\0\"" - does to_s of "offsetof(Foo, @bar)" does to_s of "offsetof(Foo, @bar)" - does to_s of "{ {1, 2, 3} => 4 }" does to_s of "{ {1, 2, 3} => 4 }" + does to_s of "1[2, x: 3, &.foo] = 4" does to_s of "1[2, x: 3, &.foo] = 4" + does to_s of "%r()" does to_s of "%r()" + does to_s of "/\\(group\\)/" does to_s of "/\\(group\\)/" + does to_s of "!a" does to_s of "!a" + does to_s of "{foo: (1 + 2)}" does to_s of "{foo: (1 + 2)}" + does to_s of "foo(x : (T -> U) -> V, W)" does to_s of "foo(x : (T -> U) -> V, W)" does to_s of "1[&.foo]" does to_s of "1[&.foo]" - does to_s of "%x(whoami)" does to_s of "%x(whoami)" - does to_s of "macro foo(@[Foo] &block)\nend" does to_s of "macro foo(@[Foo] &block)\nend" - does to_s of "macro foo(x, @[Foo] *y)\nend" does to_s of "macro foo(x, @[Foo] *y)\nend" - does to_s of "case 1; in .foo?; 2; end" does to_s of "case 1; in .foo?; 2; end" - does to_s of "-> : Int32 do\nend" does to_s of "-> : Int32 do\nend" - does to_s of "{ {1, 2, 3} }" does to_s of "{ {1, 2, 3} }" - does to_s of "macro foo(@[Foo] id)\nend" does to_s of "macro foo(@[Foo] id)\nend" - does to_s of "foo.%" does to_s of "foo.%" - does to_s of "def foo(& : (->))\nend" does to_s of "def foo(& : (->))\nend" - does to_s of "1.[](2) do\nend" does to_s of "1.[](2) do\nend" - does to_s of "if (1 + 2\n3)\n 4\nend" does to_s of "if (1 + 2\n3)\n 4\nend" - does to_s of "1 <= 2 <= 3" does to_s of "1 <= 2 <= 3" does to_s of "begin\n (1)\nend" does to_s of "begin\n (1)\nend" + does to_s of "foo do\n begin\n bar\n end\nend" does to_s of "foo do\n begin\n bar\n end\nend" + does to_s of "begin\n (1)\n 2\nend" does to_s of "begin\n (1)\n 2\nend" + does to_s of "1.[](2) do\nend" does to_s of "1.[](2) do\nend" + does to_s of "a.as?(Int32)" does to_s of "a.as?(Int32)" + does to_s of "lib LibFoo\n fun foo(x : Foo((T -> U)))\nend" does to_s of "lib LibFoo\n fun foo(x : Foo((T -> U)))\nend" + does to_s of "macro foo\n\\{{ @type }}\nend" does to_s of "macro foo\n\\{{ @type }}\nend" + does to_s of "def foo(x : (T -> U).class)\nend" does to_s of "def foo(x : (T -> U).class)\nend" + does to_s of "/a/x" does to_s of "/a/x" + does to_s of "def foo(*args)\nend" does to_s of "def foo(*args)\nend" does to_s of `#{::String.interpolation(x)}` does to_s of `#{::String.interpolation(x)}` does to_s of "macro foo(**args)\nend" does to_s of "macro foo(**args)\nend" - does to_s of "1 <= (2 <= 3)" does to_s of "1 <= (2 <= 3)" - does to_s of "asm(\"nop\" ::::)" does to_s of "asm(\"nop\" ::::)" - does to_s of "foo do |k, v|\n k.bar(1, 2, 3)\nend" does to_s of "foo do |k, v|\n k.bar(1, 2, 3)\nend" does to_s of "lib LibFoo\n fun foo(x : (T -> U).class)\nend" does to_s of "lib LibFoo\n fun foo(x : (T -> U).class)\nend" - does to_s of "def foo(@[Foo] x y)\nend" does to_s of "def foo(@[Foo] x y)\nend" - does to_s of "macro foo\n\\{%@type %}\nend" does to_s of "macro foo\n\\{%@type %}\nend" - does to_s of "foo &.bar(1, 2, 3)" does to_s of "foo &.bar(1, 2, 3)" - does to_s of "({} of K => V).foo" does to_s of "({} of K => V).foo" - does to_s of "1.//(2, a: 3)" does to_s of "1.//(2, a: 3)" - does to_s of "foo(3, &.*(2))" does to_s of "foo(3, &.*(2))" - does to_s of "foo(&.==(2))" does to_s of "foo(&.==(2))" - does to_s of "asm(\"nop\" :: \"c\"(3), \"d\"(4) ::)" does to_s of "asm(\"nop\" :: \"c\"(3), \"d\"(4) ::)" - does to_s of "1.responds_to?(:\"&&\")" does to_s of "1.responds_to?(:\"&&\")" - does to_s of "1[&.foo]?" does to_s of "1[&.foo]?" - does to_s of "asm(\"nop\" : \"a\"(1), \"b\"(2) : \"c\"(3), \"d\"(4) : \"e\", \"f\" : \"volatile\", \"alignstack\", \"intel\")" does to_s of "asm(\"nop\" : \"a\"(1), \"b\"(2) : \"c\"(3), \"d\"(4) : \"e\", \"f\" : \"volatile\", \"alignstack\", \"intel\")" - does to_s of "yield(1)" does to_s of "yield(1)" - does to_s of "1.~(2)" does to_s of "1.~(2)" - does to_s of "begin\n (1)\n 2\nrescue\nend" does to_s of "begin\n (1)\n 2\nrescue\nend" - does to_s of "Foo(\"bar baz\": Int32)" does to_s of "Foo(\"bar baz\": Int32)" - does to_s of "macro foo(&)\nend" does to_s of "macro foo(&)\nend" - does to_s of "if true\n (1)\n 2\nend" does to_s of "if true\n (1)\n 2\nend" - does to_s of "def foo(*args)\nend" does to_s of "def foo(*args)\nend" - does to_s of "{% foo %}" does to_s of "{% foo %}" - does to_s of "select\nwhen foo\n select\n when bar\n 1\n else\n 2\n end\nelse\n select\n when baz\n 3\n else\n 4\n end\nend" does to_s of "select\nwhen foo\n select\n when bar\n 1\n else\n 2\n end\nelse\n select\n when baz\n 3\n else\n 4\n end\nend" - does to_s of "foo(bar)" does to_s of "foo(bar)" - does to_s of "{% for foo in bar %}\n {{ foo }}\n{% end %}" does to_s of "{% for foo in bar %}\n {{ foo }}\n{% end %}" - does to_s of "/hello world/imx" does to_s of "/hello world/imx" - does to_s of "enum Foo\n A = 0\n B\nend" does to_s of "enum Foo\n A = 0\n B\nend" - does to_s of "def foo(x, **args, &block : _ -> _)\nend" does to_s of "def foo(x, **args, &block : _ -> _)\nend" - does to_s of "begin\n (1)\n 2\nend" does to_s of "begin\n (1)\n 2\nend" - does to_s of "macro foo\n{% verbatim do %}1{% end %}\nend" does to_s of "macro foo\n{% verbatim do %}1{% end %}\nend" - does to_s of "def foo(@[Foo] *args)\nend" does to_s of "def foo(@[Foo] *args)\nend" + does to_s of "(1 || 1.1).as(Int32)" does to_s of "(1 || 1.1).as(Int32)" + does to_s of "def foo\n yield\nend" does to_s of "def foo\n yield\nend" + does to_s of "`\\n\\0`" does to_s of "`\\n\\0`" + does to_s of "foo[x : (T -> U) -> V, W] = 1" does to_s of "foo[x : (T -> U) -> V, W] = 1" does to_s of "def foo(x : Foo((T -> U)))\nend" does to_s of "def foo(x : Foo((T -> U)))\nend" - does to_s of "->::Foo::Bar.foo" does to_s of "->::Foo::Bar.foo" - does to_s of "1_f64" does to_s of "1_f64" - does to_s of "lib LibC\n fun getch = \"get.char\"\nend" does to_s of "lib LibC\n fun getch = \"get.char\"\nend" - does to_s of "asm(\"nop\" :::: \"volatile\")" does to_s of "asm(\"nop\" :::: \"volatile\")" - does to_s of "return true ? 1 : 2" does to_s of "return true ? 1 : 2" - does to_s of "def foo(x, @[Foo] **args)\nend" does to_s of "def foo(x, @[Foo] **args)\nend" - does to_s of "あ.い, う.え.お = 1, 2" does to_s of "あ.い, う.え.お = 1, 2" - does to_s of "/\\(group\\)/" does to_s of "/\\(group\\)/" - does to_s of "{\"foo bar\": 1}" does to_s of "{\"foo bar\": 1}" - does to_s of "foo &.bar" does to_s of "foo &.bar" - does to_s of "macro foo\n {% for foo in bar %}\n {{ foo }}\n {% end %}\nend" does to_s of "macro foo\n {% for foo in bar %}\n {{ foo }}\n {% end %}\nend" - does to_s of "\"\#{(1 + 2)}\"" does to_s of "\"\#{(1 + 2)}\"" - does to_s of "1.+(&block)" does to_s of "1.+(&block)" does to_s of "(1 & 2) & (3 | 4)" does to_s of "(1 & 2) & (3 | 4)" - does to_s of "foo(x : (T -> U) -> V, W)" does to_s of "foo(x : (T -> U) -> V, W)" - does to_s of "1e10_f64" does to_s of "1e10_f64" - does to_s of "macro foo(x, @[Foo] **args)\nend" does to_s of "macro foo(x, @[Foo] **args)\nend" - does to_s of "`\\n\\0`" does to_s of "`\\n\\0`" - does to_s of "foo.*" does to_s of "foo.*" - does to_s of "foo(a.as(Int32))" does to_s of "foo(a.as(Int32))" - does to_s of "{ {1 => 2} }" does to_s of "{ {1 => 2} }" - does to_s of "foo.nil?" does to_s of "foo.nil?" - does to_s of ":foo" does to_s of ":foo" - does to_s of "macro foo(*var)\nend" does to_s of "macro foo(*var)\nend" - does to_s of "def foo(x : (T -> U) | V)\nend" does to_s of "def foo(x : (T -> U) | V)\nend" - does to_s of "%r()" does to_s of "%r()" - does to_s of "foo(x : Foo((T -> U)))" does to_s of "foo(x : Foo((T -> U)))" - does to_s of "%r{\\/\\0}" does to_s of "%r{\\/\\0}" - does to_s of "(1 + 2)..3" does to_s of "(1 + 2)..3" - does to_s of "lib Foo\n union Foo\n a : Int\n b : Int32\n end\nend" does to_s of "lib Foo\n union Foo\n a : Int\n b : Int32\n end\nend" - does to_s of "macro foo\n\\{{ @type }}\nend" does to_s of "macro foo\n\\{{ @type }}\nend" - does to_s of "{foo: (1 + 2)}" does to_s of "{foo: (1 + 2)}" - does to_s of "case 1; when .foo?; 2; end" does to_s of "case 1; when .foo?; 2; end" - does to_s of "foo[x : (T -> U) -> V, W]" does to_s of "foo[x : (T -> U) -> V, W]" - does to_s of "foo(x : (T -> U) | V)" does to_s of "foo(x : (T -> U) | V)" - does to_s of "(a = 2) && 1" does to_s of "(a = 2) && 1" - does to_s of "@[Foo(1, 2, a: 1, b: 2)]" does to_s of "@[Foo(1, 2, a: 1, b: 2)]" - does to_s of "{ {foo: 2} }" does to_s of "{ {foo: 2} }" - does to_s of "1.+ do\nend" does to_s of "1.+ do\nend" - does to_s of "foo { |(x, y)| x }" does to_s of "foo { |(x, y)| x }" + does to_s of "/\\//" does to_s of "/\\//" + does to_s of "macro foo(@[Foo] id)\nend" does to_s of "macro foo(@[Foo] id)\nend" + does to_s of "macro foo\n %bar = 1; end" does to_s of "macro foo\n %bar = 1; end" + does to_s of "def foo(@[Foo] *args)\nend" does to_s of "def foo(@[Foo] *args)\nend" + does to_s of "{% verbatim do %}\n 1{{ 2 }}\n 3{{ 4 }}\n{% end %}" does to_s of "{% verbatim do %}\n 1{{ 2 }}\n 3{{ 4 }}\n{% end %}" + does to_s of "macro foo\n {% for foo in bar %}\n {{ foo }}\n {% end %}\nend" does to_s of "macro foo\n {% for foo in bar %}\n {{ foo }}\n {% end %}\nend" + does to_s of "def foo(x, **args, &block : _ -> _)\nend" does to_s of "def foo(x, **args, &block : _ -> _)\nend" does to_s of "foo._bar(1)" does to_s of "foo._bar(1)" - does to_s of "/\\?/" does to_s of "/\\?/" - does to_s of "@foo.bar" does to_s of "@foo.bar" - does to_s of "asm(\"nop\" :: \"a\"(1) :: \"volatile\")" does to_s of "asm(\"nop\" :: \"a\"(1) :: \"volatile\")" - does to_s of "1.+(a: 2)" does to_s of "1.+(a: 2)" - does to_s of ":\"{\"" does to_s of ":\"{\"" - does to_s of "(1..)" does to_s of "(1..)" - does to_s of "def foo(x : T = 1)\nend" does to_s of "def foo(x : T = 1)\nend" - does to_s of "lib Foo\n struct Foo\n a : Void\n b : Void\n end\nend" does to_s of "lib Foo\n struct Foo\n a : Void\n b : Void\n end\nend" - does to_s of "def foo(x : (T -> U) -> V, *args : (T -> U) -> V, y : (T -> U) -> V, **opts : (T -> U) -> V, & : (T -> U) -> V) : ((T -> U) -> V)\nend" does to_s of "def foo(x : (T -> U) -> V, *args : (T -> U) -> V, y : (T -> U) -> V, **opts : (T -> U) -> V, & : (T -> U) -> V) : ((T -> U) -> V)\nend" - does to_s of "def foo(x, **args, &block)\nend" does to_s of "def foo(x, **args, &block)\nend" - does to_s of "# doc\ndef foo\nend" does to_s of "# doc\ndef foo\nend" - does to_s of "def foo(**options, &block)\nend" does to_s of "def foo(**options, &block)\nend" - does to_s of "macro foo(*, __var var)\nend" does to_s of "macro foo(*, __var var)\nend" - does to_s of "enum A : B\nend" does to_s of "enum A : B\nend" - does to_s of "{(1 + 2) => (3 + 4)}" does to_s of "{(1 + 2) => (3 + 4)}" - does to_s of "def foo(x)\n yield\nend" does to_s of "def foo(x)\n yield\nend" - does to_s of "1[&.foo] = 2" does to_s of "1[&.foo] = 2" - does to_s of "macro foo\n %bar{1, x} = 1\nend" does to_s of "macro foo\n %bar{1, x} = 1\nend" - does to_s of "if true\n (1)\nend" does to_s of "if true\n (1)\nend" + does to_s of "def foo(@[Foo] x y)\nend" does to_s of "def foo(@[Foo] x y)\nend" + does to_s of "alias Foo = Void" does to_s of "alias Foo = Void" does to_s of "1_f32" does to_s of "1_f32" - does to_s of "foo[x, y, a: 1, b: 2] = z" does to_s of "foo[x, y, a: 1, b: 2] = z" - does to_s of "def foo(@[Foo] **args)\nend" does to_s of "def foo(@[Foo] **args)\nend" + does to_s of "macro foo(@[Foo] &block)\nend" does to_s of "macro foo(@[Foo] &block)\nend" does to_s of "foo(x : (T -> U).class)" does to_s of "foo(x : (T -> U).class)" + does to_s of "macro foo(x, **args)\nend" does to_s of "macro foo(x, **args)\nend" does to_s of "def foo(\"bar baz\" qux)\nend" does to_s of "def foo(\"bar baz\" qux)\nend" - does to_s of "lib Foo::Bar\nend" does to_s of "lib Foo::Bar\nend" - does to_s of "macro foo\n{{ @type }}\nend" does to_s of "macro foo\n{{ @type }}\nend" - does to_s of "type(Foo = Void)" does to_s of "type(Foo = Void)" - does to_s of "macro foo\n{% @type %}\nend" does to_s of "macro foo\n{% @type %}\nend" + does to_s of "def foo(& : (->))\nend" does to_s of "def foo(& : (->))\nend" + does to_s of "return begin\n 1\n 2\nend" does to_s of "return begin\n 1\n 2\nend" + does to_s of "/\\s/" does to_s of "/\\s/" + does to_s of "_foo.bar" does to_s of "_foo.bar" + does to_s of "begin\n (1)\nrescue\nend" does to_s of "begin\n (1)\nrescue\nend" + does to_s of "(a = 2) && 1" does to_s of "(a = 2) && 1" + does to_s of x = (1 +2 +) does to_s of x = (1 +2 +) + does to_s of "case 1; in .foo?; 2; end" does to_s of "case 1; in .foo?; 2; end" + does to_s of "\"\#{(1 + 2)}\"" does to_s of "\"\#{(1 + 2)}\"" + does to_s of "if true\n (1)\n 2\nend" does to_s of "if true\n (1)\n 2\nend" + does to_s of "foo x: 1, y: 2, &.bar" does to_s of "foo x: 1, y: 2, &.bar" + does to_s of "{ {foo: 2} }" does to_s of "{ {foo: 2} }" does to_s of "macro foo(&block)\nend" does to_s of "macro foo(&block)\nend" - does to_s of "lib LibC\n fun getchar(Int, Float)\nend" does to_s of "lib LibC\n fun getchar(Int, Float)\nend" - does to_s of "fun foo(a : Void, b : Void, ...) : Void\nend" does to_s of "fun foo(a : Void, b : Void, ...) : Void\nend" - does to_s of "(1 <= 2) <= 3" does to_s of "(1 <= 2) <= 3" - does to_s of "1.responds_to?(:to_s)" does to_s of "1.responds_to?(:to_s)" - does to_s of "{(1 + 2)}" does to_s of "{(1 + 2)}" - does to_s of "lib Foo\n FOO = 0\nend" does to_s of "lib Foo\n FOO = 0\nend" - does to_s of "def foo(**args : T)\nend" does to_s of "def foo(**args : T)\nend" - does to_s of "def foo(*args : _)\nend" does to_s of "def foo(*args : _)\nend" - does to_s of "begin\n (@x = x).is_a?(Foo)\nend" does to_s of "begin\n (@x = x).is_a?(Foo)\nend" - does to_s of "def foo\n yield\nend" does to_s of "def foo\n yield\nend" - does to_s of "macro foo(*, var)\nend" does to_s of "macro foo(*, var)\nend" - does to_s of "1.//(2, &block)" does to_s of "1.//(2, &block)" - does to_s of "foo { |i| i.bar { i } }" does to_s of "foo { |i| i.bar { i } }" - does to_s of "macro foo\n %bar = 1; end" does to_s of "macro foo\n %bar = 1; end" - does to_s of "1.as(Int32)" does to_s of "1.as(Int32)" - does to_s of "/a/x" does to_s of "/a/x" - does to_s of "foo[x, y, a: 1, b: 2]" does to_s of "foo[x, y, a: 1, b: 2]" - does to_s of "macro foo(@[Foo] &)\nend" does to_s of "macro foo(@[Foo] &)\nend" - does to_s of "case 1; when .!; 2; when .< 0; 3; end" does to_s of "case 1; when .!; 2; when .< 0; 3; end" - does to_s of "{% if foo %}\n foo_then\n{% else %}\n foo_else\n{% end %}" does to_s of "{% if foo %}\n foo_then\n{% else %}\n foo_else\n{% end %}" + does to_s of "def foo(x, **args, &block : (_ -> _))\nend" does to_s of "def foo(x, **args, &block : (_ -> _))\nend" + does to_s of "lib LibFoo\n fun foo(x : (T -> U) -> V, W) : ((T -> U) -> V)\nend" does to_s of "lib LibFoo\n fun foo(x : (T -> U) -> V, W) : ((T -> U) -> V)\nend" + does to_s of "[(1 + 2)] of Int32" does to_s of "[(1 + 2)] of Int32" + does to_s of "macro foo(&)\nend" does to_s of "macro foo(&)\nend" + does to_s of "1[&.foo]?" does to_s of "1[&.foo]?" + does to_s of "foo(3, &.*(2))" does to_s of "foo(3, &.*(2))" + does to_s of "macro foo(@[Foo] **args)\nend" does to_s of "macro foo(@[Foo] **args)\nend" + does to_s of "(1 + 2).as?(Int32)" does to_s of "(1 + 2).as?(Int32)" does to_s of "..3" does to_s of "..3" - does to_s of "case 1\nwhen .[](2)\n 3\nwhen .[]=(4)\n 5\nend" does to_s of "case 1\nwhen .[](2)\n 3\nwhen .[]=(4)\n 5\nend" - does to_s of "foo._bar" does to_s of "foo._bar" - does to_s of "/\\//" does to_s of "/\\//" + does to_s of "1[&.foo] = 2" does to_s of "1[&.foo] = 2" + does to_s of "->::Foo::Bar.foo" does to_s of "->::Foo::Bar.foo" + does to_s of "/\#{1 / 2}/" does to_s of "/\#{1 / 2}/" + does to_s of "foo { |(x, (y, z))| x }" does to_s of "foo { |(x, (y, z))| x }" + does to_s of "def foo(**args : T)\nend" does to_s of "def foo(**args : T)\nend" + does to_s of ":foo" does to_s of ":foo" does to_s of "1.~(2) do\nend" does to_s of "1.~(2) do\nend" - does to_s of "lib Foo\n A = Pointer(Void).new(0)\n struct B\n x : Void*\n y : Int[1]\n end\n fun c(Void*) : Char[2]*\nend" does to_s of "lib Foo\n A = Pointer(Void).new(0)\n struct B\n x : Void*\n y : Int[1]\n end\n fun c(Void*) : Char[2]*\nend" - does to_s of "Foo()" does to_s of "Foo()" - does to_s of "foo : (A | B).class" does to_s of "foo : (A | B).class" - does to_s of "macro foo\n %bar = 1\nend" does to_s of "macro foo\n %bar = 1\nend" - does to_s of "foo do\n begin\n bar\n end\nend" does to_s of "foo do\n begin\n bar\n end\nend" does to_s of "alias Foo::Bar = Void" does to_s of "alias Foo::Bar = Void" - does to_s of "(1 || 1.1).as(Int32)" does to_s of "(1 || 1.1).as(Int32)" - does to_s of "def foo(**x)\n yield\nend" does to_s of "def foo(**x)\n yield\nend" - does to_s of "def foo(& : ->)\nend" does to_s of "def foo(& : ->)\nend" - does to_s of "(1 + 2).as(Int32)" does to_s of "(1 + 2).as(Int32)" + does to_s of "def foo(@[Foo] x, @[Bar] **args, @[Baz] &block)\nend" does to_s of "def foo(@[Foo] x, @[Bar] **args, @[Baz] &block)\nend" + does to_s of "def foo(x : X, y : Y) forall X, Y\nend" does to_s of "def foo(x : X, y : Y) forall X, Y\nend" + does to_s of "foo[x : (T -> U) -> V, W]" does to_s of "foo[x : (T -> U) -> V, W]" + does to_s of "{\"foo bar\": 1}" does to_s of "{\"foo bar\": 1}" + does to_s of "foo &.bar" does to_s of "foo &.bar" + does to_s of "class Foo\n # doc\n def foo\n end\nend" does to_s of "class Foo\n # doc\n def foo\n end\nend" + does to_s of "lib Foo\n union Foo\n a : Int\n b : Int32\n end\nend" does to_s of "lib Foo\n union Foo\n a : Int\n b : Int32\n end\nend" + does to_s of "def foo(**args)\nend" does to_s of "def foo(**args)\nend" + does to_s of "foo(&.==(2))" does to_s of "foo(&.==(2))" + does to_s of "1e10_f64" does to_s of "1e10_f64" + does to_s of "def foo(**options, &block)\nend" does to_s of "def foo(**options, &block)\nend" + does to_s of "macro foo\n 123\nend" does to_s of "macro foo\n 123\nend" + does to_s of "def foo(@[Foo] x : T = 1)\nend" does to_s of "def foo(@[Foo] x : T = 1)\nend" + does to_s of "asm(\"nop\" :: \"c\"(3), \"d\"(4) ::)" does to_s of "asm(\"nop\" :: \"c\"(3), \"d\"(4) ::)" + does to_s of "&+1" does to_s of "&+1" + does to_s of "asm(\"nop\" ::::)" does to_s of "asm(\"nop\" ::::)" does to_s of "%r(/)" does to_s of "%r(/)" - does to_s of "/\\s/" does to_s of "/\\s/" + does to_s of "1 & 2 & (3 | 4)" does to_s of "1 & 2 & (3 | 4)" + does to_s of "lib LibFoo\n fun foo(x : (T -> U) | V)\nend" does to_s of "lib LibFoo\n fun foo(x : (T -> U) | V)\nend" + does to_s of "Foo(\"bar baz\": Int32)" does to_s of "Foo(\"bar baz\": Int32)" + does to_s of "def foo(@[Foo] **args)\nend" does to_s of "def foo(@[Foo] **args)\nend" + does to_s of "macro foo(*var)\nend" does to_s of "macro foo(*var)\nend" + does to_s of ":\"{\"" does to_s of ":\"{\"" + does to_s of "{(1 + 2)}" does to_s of "{(1 + 2)}" + does to_s of "1.+ do\nend" does to_s of "1.+ do\nend" + does to_s of "asm(\"nop\" : \"a\"(1), \"b\"(2) : \"c\"(3), \"d\"(4) : \"e\", \"f\" : \"volatile\", \"alignstack\", \"intel\")" does to_s of "asm(\"nop\" : \"a\"(1), \"b\"(2) : \"c\"(3), \"d\"(4) : \"e\", \"f\" : \"volatile\", \"alignstack\", \"intel\")" + does to_s of "def foo(**x)\n yield\nend" does to_s of "def foo(**x)\n yield\nend" + does to_s of "def foo(x)\n yield\nend" does to_s of "def foo(x)\n yield\nend" + does to_s of "foo : (A | B).class" does to_s of "foo : (A | B).class" + does to_s of "%(\"\#{foo}\")" does to_s of "%(\"\#{foo}\")" + does to_s of "%x(whoami)" does to_s of "%x(whoami)" + does to_s of "1.//(2, a: 3)" does to_s of "1.//(2, a: 3)" + does to_s of "({} of K => V).foo" does to_s of "({} of K => V).foo" + does to_s of "def foo(x : T = 1)\nend" does to_s of "def foo(x : T = 1)\nend" + does to_s of "/\\?/" does to_s of "/\\?/" + does to_s of "{ {1, 2, 3} => 4 }" does to_s of "{ {1, 2, 3} => 4 }" + does to_s of "lib LibC\n fun getch = \"get.char\"\nend" does to_s of "lib LibC\n fun getch = \"get.char\"\nend" + does to_s of "macro foo\n %bar = 1\nend" does to_s of "macro foo\n %bar = 1\nend" + does to_s of "if true\n (1)\nend" does to_s of "if true\n (1)\nend" + does to_s of "macro foo(@[Foo] &)\nend" does to_s of "macro foo(@[Foo] &)\nend" + does to_s of "/hello world/" does to_s of "/hello world/" + does to_s of "{% if foo %}\n foo_then\n{% end %}" does to_s of "{% if foo %}\n foo_then\n{% end %}" + does to_s of "def foo(x, **args, &block)\nend" does to_s of "def foo(x, **args, &block)\nend" + does to_s of "foo.nil?" does to_s of "foo.nil?" does to_s of "1.&**" does to_s of "1.&**" + does to_s of "macro foo\n{% verbatim do %}1{% end %}\nend" does to_s of "macro foo\n{% verbatim do %}1{% end %}\nend" + does to_s of "def foo(*args : _)\nend" does to_s of "def foo(*args : _)\nend" + does to_s of "macro foo\n{{ @type }}\nend" does to_s of "macro foo\n{{ @type }}\nend" + does to_s of "1.responds_to?(:to_s)" does to_s of "1.responds_to?(:to_s)" + does to_s of "foo : A | (B -> C)" does to_s of "foo : A | (B -> C)" does to_s of "foo()" does to_s of "foo()" - does to_s of "([] of T).foo" does to_s of "([] of T).foo" - does to_s of "def foo(x, **args)\nend" does to_s of "def foo(x, **args)\nend" - does to_s of "[(1 + 2)] of Int32" does to_s of "[(1 + 2)] of Int32" - does to_s of "!a" does to_s of "!a" - does to_s of "def foo(x, **args, &block : (_ -> _))\nend" does to_s of "def foo(x, **args, &block : (_ -> _))\nend" - does to_s of "asm(\"nop\" ::: \"e\" : \"volatile\")" does to_s of "asm(\"nop\" ::: \"e\" : \"volatile\")" - does to_s of "macro foo(x, *y)\nend" does to_s of "macro foo(x, *y)\nend" - does to_s of "def foo(@[Foo] x, @[Bar] **args, @[Baz] &block)\nend" does to_s of "def foo(@[Foo] x, @[Bar] **args, @[Baz] &block)\nend" - does to_s of "1 && (a = 2)" does to_s of "1 && (a = 2)" - does to_s of "class Foo\n private def bar\n end\nend" does to_s of "class Foo\n private def bar\n end\nend" - does to_s of "lib LibFoo\n fun foo(x : (T -> U) -> V, W) : ((T -> U) -> V)\nend" does to_s of "lib LibFoo\n fun foo(x : (T -> U) -> V, W) : ((T -> U) -> V)\nend" - does to_s of "1[2, x: 3, &.foo] = 4" does to_s of "1[2, x: 3, &.foo] = 4" - does to_s of "def foo(x y)\nend" does to_s of "def foo(x y)\nend" - does to_s of "(1 + 2).as?(Int32)" does to_s of "(1 + 2).as?(Int32)" - does to_s of "&-1" does to_s of "&-1" - does to_s of "{% verbatim do %}\n 1{{ 2 }}\n 3{{ 4 }}\n{% end %}" does to_s of "{% verbatim do %}\n 1{{ 2 }}\n 3{{ 4 }}\n{% end %}" - does to_s of "macro foo(x, **args)\nend" does to_s of "macro foo(x, **args)\nend" + does to_s of "macro foo(x, @[Foo] **args)\nend" does to_s of "macro foo(x, @[Foo] **args)\nend" + does to_s of "def foo(x : X, @[Foo] y : Y) forall X, Y\nend" does to_s of "def foo(x : X, @[Foo] y : Y) forall X, Y\nend" does to_s of "他.说(\"你好\")" does to_s of "他.说(\"你好\")" - does to_s of "1.&*" does to_s of "1.&*" - does to_s of "\"\\e\\0\\\"\"" does to_s of "\"\\e\\0\\\"\"" - does to_s of "lib LibFoo\n fun foo(x : Foo((T -> U)))\nend" does to_s of "lib LibFoo\n fun foo(x : Foo((T -> U)))\nend" - does to_s of "%r( )" does to_s of "%r( )" - does to_s of "lib LibFoo\n fun foo(x : (T -> U) | V)\nend" does to_s of "lib LibFoo\n fun foo(x : (T -> U) | V)\nend" - does to_s of "1[2, x: 3, &.foo]?" does to_s of "1[2, x: 3, &.foo]?" - does to_s of "1.[]=" does to_s of "1.[]=" + does to_s of "->::foo(Int32, String)" does to_s of "->::foo(Int32, String)" + does to_s of "%r{\#{1}\\/\\0}" does to_s of "%r{\#{1}\\/\\0}" + does to_s of "1.//(2, &block)" does to_s of "1.//(2, &block)" + does to_s of "foo(a.as(Int32))" does to_s of "foo(a.as(Int32))" + does to_s of "/hello world/imx" does to_s of "/hello world/imx" + does to_s of "1.responds_to?(:\"&&\")" does to_s of "1.responds_to?(:\"&&\")" + does to_s of "return true ? 1 : 2" does to_s of "return true ? 1 : 2" + does to_s of "case 1; when .foo?; 2; end" does to_s of "case 1; when .foo?; 2; end" does to_s of "{{ foo }}" does to_s of "{{ foo }}" - does to_s of "begin\n (1)\nrescue\nend" does to_s of "begin\n (1)\nrescue\nend" -Code gen: c enum - codegens enum with 1 << 3 codegens enum with 1 << 3 - codegens enum with (1 + 2) * 3 codegens enum with (1 + 2) * 3 - codegens enum value 2 codegens enum value 2 - codegens enum with 3 &- 2 codegens enum with 3 &- 2 - codegens enum value codegens enum value - codegens enum with 3 * 2 codegens enum with 3 * 2 - codegens enum value 3 codegens enum value 3 - codegens enum that refers to another constant codegens enum that refers to another constant - codegens enum with 1 + 2 codegens enum with 1 + 2 - codegens enum value 4 codegens enum value 4 - codegens enum that refers to another enum constant codegens enum that refers to another enum constant - codegens enum with +1 codegens enum with +1 - codegens enum with 10 ^ 3 codegens enum with 10 ^ 3 - codegens enum with 3 - 2 codegens enum with 3 - 2 - codegens enum with 10 % 3 codegens enum with 10 % 3 - codegens enum with 10 & 3 codegens enum with 10 & 3 - codegens enum with 1 &+ 2 codegens enum with 1 &+ 2 - codegens enum with ~1 codegens enum with ~1 - codegens enum with 100 >> 3 codegens enum with 100 >> 3 - codegens enum with -1 codegens enum with -1 - codegens enum with 3 &* 2 codegens enum with 3 &* 2 - codegens enum with 10 // 2 codegens enum with 10 // 2 - codegens enum with 10 | 3 codegens enum with 10 | 3 -Semantic: named args - matches specific overload with named arguments (#2753) matches specific overload with named arguments (#2753) - overloads based on required named args, with restrictions overloads based on required named args, with restrictions - errors if named arg already specified errors if named arg already specified - errors if named arg already specified but in same position errors if named arg already specified but in same position - errors if missing one argument errors if missing one argument - allows named arg if there's a splat allows named arg if there's a splat - passes #2696 passes #2696 - sends two regular arguments as named arguments sends two regular arguments as named arguments - errors if named arg already specified errors if named arg already specified - says correct error when forwarding named args (#7491) says correct error when forwarding named args (#7491) - sends two regular arguments as named arguments in inverted position (2) sends two regular arguments as named arguments in inverted position (2) - gives correct error message with external names (#3934) gives correct error message with external names (#3934) - overloads based on required named args overloads based on required named args - says no overload matches with named arg says no overload matches with named arg - errors if missing two arguments errors if missing two arguments - doesn't include arguments with default values in missing arguments error doesn't include arguments with default values in missing arguments error - errors if named arg not found in new errors if named arg not found in new - errors if named arg matches splat argument errors if named arg matches splat argument - doesn't fail on named argument with NoReturn type (#7760) doesn't fail on named argument with NoReturn type (#7760) - errors if named arg matches single splat argument errors if named arg matches single splat argument - gives correct error message for missing args after * gives correct error message for missing args after * - errors if named arg not found errors if named arg not found - sends one regular argument as named argument sends one regular argument as named argument - errors if doesn't pass named arg restriction errors if doesn't pass named arg restriction - uses bare splat in new uses bare splat in new - errors if named arg already specified, but multiple overloads (#7281) errors if named arg already specified, but multiple overloads (#7281) - matches specific overload with named arguments (2) (#2753) matches specific overload with named arguments (2) (#2753) - sends two regular arguments as named arguments in inverted position (1) sends two regular arguments as named arguments in inverted position (1) -Code gen: c union - codegens struct inside union codegens struct inside union - codegens union property setter 2 via pointer codegens union property setter 2 via pointer - automatically converts by invoking to_unsafe automatically converts by invoking to_unsafe - codegens union property setter 1 codegens union property setter 1 - automatically converts numeric union type in field assignment automatically converts numeric union type in field assignment - codegens union property default value codegens union property default value - automatically converts numeric type in field assignment automatically converts numeric type in field assignment - reads union instance var reads union instance var - moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) moves unions around correctly (#12550) - codegens assign c union to union codegens assign c union to union - aligns to the member with biggest align requirements aligns to the member with biggest align requirements - does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s does to_s - codegens union property default value 2 codegens union property default value 2 - builds union setter with fun type builds union setter with fun type - codegens union property setter 1 via pointer codegens union property setter 1 via pointer - codegens union property setter 2 codegens union property setter 2 - fills union type to the max size fills union type to the max size -Semantic: static array - can match number type argument of static array (#1203) can match number type argument of static array (#1203) - errors on negative static array size errors on negative static array size - allows instantiating static array instance var in initialize of generic type allows instantiating static array instance var in initialize of generic type - types static array new types static array new - doesn't crash on restriction (#584) doesn't crash on restriction (#584) - types static array new with size being a constant types static array new with size being a constant - doesn't match other number type argument of static array (#1203) doesn't match other number type argument of static array (#1203) - types static array new with size being a computed constant, and use N (bug) types static array new with size being a computed constant, and use N (bug) - doesn't crash on offsetof (#8858) doesn't crash on offsetof (#8858) - types static array with var declaration types static array with var declaration - types static array new with size being a nested constant inside type declaration (#5426) types static array new with size being a nested constant inside type declaration (#5426) - can match N type argument of static array (#1203) can match N type argument of static array (#1203) - types static array new with size being a computed constant types static array new with size being a computed constant - errors if trying to instantiate static array with N not an integer errors if trying to instantiate static array with N not an integer - types static array with type as size types static array with type as size - doesn't crash on sizeof (#8858) doesn't crash on sizeof (#8858) - doesn't crash on instance_sizeof (#8858) doesn't crash on instance_sizeof (#8858) -Crystal::Repl::Interpreter - does call without receiver inside closure does call without receiver inside closure - procs - interprets no args proc literal interprets no args proc literal - casts from nilable proc type to proc type casts from nilable proc type to proc type - can downcast Proc(T) to Proc(Nil) can downcast Proc(T) to Proc(Nil) - interprets call inside Proc type interprets call inside Proc type - discards proc call discards proc call - interprets proc literal with args interprets proc literal with args - calls proc primitive on union of module that has no subtypes (#12954) calls proc primitive on union of module that has no subtypes (#12954) - casts proc call arguments to proc arg types (#12350) casts proc call arguments to proc arg types (#12350) -Crystal::Repl::Interpreter - variadic calls - promotes int promotes int - promotes float promotes float - promotes enum promotes enum - command expansion - expands ldflags expands ldflags -Code gen: alias - lazily solves aliases (#1346) lazily solves aliases (#1346) - casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias casts to recursive alias - invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) invokes methods on empty array of recursive alias (2) - overloads alias against generic (2) (#3261) overloads alias against generic (2) (#3261) - overloads alias against generic (1) (#3261) overloads alias against generic (1) (#3261) - doesn't break with alias for link attributes doesn't break with alias for link attributes - codegens cast to alias that includes bool codegens cast to alias that includes bool - invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) invokes methods on empty array of recursive alias (3) - invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) invokes methods on empty array of recursive alias (1) - casts to recursive alias casts to recursive alias - doesn't crash on cast to as recursive alias (#639) doesn't crash on cast to as recursive alias (#639) -Semantic: automatic cast - doesn't autocast number on union (#8655) doesn't autocast number on union (#8655) - casts Int32 to Int64 in ivar assignment casts Int32 to Int64 in ivar assignment - errors when autocast default value doesn't match enum member errors when autocast default value doesn't match enum member - can autocast to union in default value (symbol and int) can autocast to union in default value (symbol and int) - can match multiple times with the same argument type (#7578) can match multiple times with the same argument type (#7578) - casts Symbol to Enum in ivar assignment casts Symbol to Enum in ivar assignment - casts literal integer (Int32 -> Float32) casts literal integer (Int32 -> Float32) - doesn't say 'ambiguous call' when there's an exact match for symbol (#6601) doesn't say 'ambiguous call' when there's an exact match for symbol (#6601) - casts Symbol to Enum in ivar type declaration casts Symbol to Enum in ivar type declaration - doesn't do multidispatch if an overload matches exactly (#8217) doesn't do multidispatch if an overload matches exactly (#8217) - casts literal integer in private top-level method (#7016) casts literal integer in private top-level method (#7016) - doesn't do multidispatch if an overload matches exactly (#8217) doesn't do multidispatch if an overload matches exactly (#8217) - autocasts float32 variable to float64 type (#9565) autocasts float32 variable to float64 type (#9565) - casts literal float (Float32 -> Float64) casts literal float (Float32 -> Float64) - casts integer expression to larger type (#9565) casts integer expression to larger type (#9565) - casts Int32 to Int64 in cvar assignment casts Int32 to Int64 in cvar assignment - autocasts nested type from non-nested type (#10315) autocasts nested type from non-nested type (#10315) - doesn't say 'ambiguous call' when there's an exact match for integer (#6601) doesn't say 'ambiguous call' when there's an exact match for integer (#6601) - can use automatic cast with `with ... yield` (#7736) can use automatic cast with `with ... yield` (#7736) - casts integer variable to larger type (#9565) casts integer variable to larger type (#9565) - doesn't cast integer variable to larger type (not #9565) doesn't cast integer variable to larger type (not #9565) - casts integer variable to larger type (Int64 to Int128) (#9565) casts integer variable to larger type (Int64 to Int128) (#9565) - casts Int32 to Int64 in lvar assignment casts Int32 to Int64 in lvar assignment - says ambiguous call for symbol says ambiguous call for symbol - casts literal integer through alias with union casts literal integer through alias with union - matches correct overload matches correct overload - casts Int32 to Int64 in ivar type declaration casts Int32 to Int64 in ivar type declaration - says ambiguous call for integer says ambiguous call for integer - casts literal integer through alias with union casts literal integer through alias with union - casts literal integer (Int32 -> Float64) casts literal integer (Int32 -> Float64) - casts literal integer (Int64 -> Int32, ok) casts literal integer (Int64 -> Int32, ok) - casts Symbol to Enum in cvar type declaration casts Symbol to Enum in cvar type declaration - casts literal integer (Int32 -> Int64) casts literal integer (Int32 -> Int64) - autocasts first argument and second matches without autocast autocasts first argument and second matches without autocast - can autocast to union in default value can autocast to union in default value - autocasts integer variable to float type (#9565) autocasts integer variable to float type (#9565) - says ambiguous call for integer var to union type (#9565) says ambiguous call for integer var to union type (#9565) - says ambiguous call for integer var to larger type (#9565) says ambiguous call for integer var to larger type (#9565) - casts literal integer (Int32 -> no restriction) casts literal integer (Int32 -> no restriction) - casts Int32 to Int64 in ivar type declaration in generic casts Int32 to Int64 in ivar type declaration in generic - casts symbol literal to enum casts symbol literal to enum - can autocast to alias in default value can autocast to alias in default value - errors if symbol name doesn't match enum member errors if symbol name doesn't match enum member - casts literal integer (Int64 -> Int32, too big) casts literal integer (Int64 -> Int32, too big) - says ambiguous call for integer (2) says ambiguous call for integer (2) - casts literal float (Float64 -> Float32) casts literal float (Float64 -> Float32) - says ambiguous call for integer on alias (#6620) says ambiguous call for integer on alias (#6620) - casts Int32 to Int64 in cvar type declaration casts Int32 to Int64 in cvar type declaration - can autocast to union in default value (multiple enums) can autocast to union in default value (multiple enums) - can't cast integer to another type when it doesn't fit (#9565) can't cast integer to another type when it doesn't fit (#9565) - casts Int32 -> Int64 in arg restriction casts Int32 -> Int64 in arg restriction - says ambiguous call on union (#8655) says ambiguous call on union (#8655) -Codegen: extern struct - declares extern union, sets and gets instance var declares extern union, sets and gets instance var - declares extern struct with no constructor declares extern struct with no constructor - codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI codegens proc that takes an extern struct with C ABI - doesn't crash with proc with extern struct that's a closure doesn't crash with proc with extern struct that's a closure - sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct sets callback on extern struct - codegens proc that takes and returns large extern struct by value codegens proc that takes and returns large extern struct by value - declares extern union with no constructor declares extern union with no constructor - declares extern struct, sets and gets instance var declares extern struct, sets and gets instance var - codegens extern proc call twice (#4982) codegens extern proc call twice (#4982) - codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret codegens proc that takes and returns an extern struct with sret - codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI - codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil codegens proc that takes an extern struct with C ABI, callback returns nil - invokes proc with extern struct with sret invokes proc with extern struct with sret - codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI codegens proc that takes and returns an extern struct with C ABI - sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union sets callback on extern union - invokes proc with extern struct invokes proc with extern struct - declares extern struct with no constructor, assigns var declares extern struct with no constructor, assigns var - codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) codegens proc that takes an extern struct with C ABI (2) -context - can get context inside a module can get context inside a module - can get context inside initialize can get context inside initialize - does includes regex special variables does includes regex special variables - can't get context from uncalled method can't get context from uncalled method - includes args includes args - can get context of yielded block can get context of yielded block - can display json output can display json output - can display text output can display text output - includes top level vars includes top level vars - does includes args, instance vars, local variables and expressions on instance methods does includes args, instance vars, local variables and expressions on instance methods - can get context in contained class' class method can get context in contained class' class method - does includes self on classes does includes self on classes - can get context of nested yielded block can get context of nested yielded block - use type filters from if var use type filters from if var - can get context in file private method can get context in file private method - can get context of empty def can get context of empty def - includes last call includes last call - can get context in file private module can get context in file private module - use type filters from is_a? use type filters from is_a? - includes assignments includes assignments - can handle union types can handle union types - includes block args includes block args - does not includes temp variables does not includes temp variables - can get context in generic class can get context in generic class - consider different instances of def consider different instances of def - can get context of empty yielded block can get context of empty yielded block - can get context inside class methods can get context inside class methods -Semantic: nil - restricts type of 'if foo' restricts type of 'if foo' - types empty types empty - marks instance variables as nil when not in initialize marks instance variables as nil when not in initialize - restricts type of 'while foo' restricts type of 'while foo' - doesn't check return type for nil doesn't check return type for nil - types nil types nil - restricts type of 'if foo' on assign restricts type of 'if foo' on assign - doesn't check return type for void doesn't check return type for void - marks instance variables as nil when not in initialize 2 marks instance variables as nil when not in initialize 2 - restricts type of 'while foo' on assign restricts type of 'while foo' on assign - can call a fun with nil for typedef pointer can call a fun with nil for typedef pointer - can call a fun with nil for pointer can call a fun with nil for pointer - marks instance variables as nil but doesn't explode on macros marks instance variables as nil but doesn't explode on macros -Restrictions - restricts class union type to overloads with classes (2) restricts class union type to overloads with classes (2) - errors if using typeof in block restriction errors if using typeof in block restriction - matches number in bound free variable (#13605) matches number in bound free variable (#13605) - restricts class union type to overloads with classes restricts class union type to overloads with classes - errors if can't find type on lookup with nested type errors if can't find type on lookup with nested type - sets number as free variable (#2699) sets number as free variable (#2699) - errors on T::Type that's a union when used from block type restriction errors on T::Type that's a union when used from block type restriction - self always matches instance type in restriction self always matches instance type in restriction - restrict - restricts generic module instance with another generic module instance restricts generic module instance with another generic module instance - restricts class against uninstantiated generic base class through multiple inheritance (2) (#9660) restricts class against uninstantiated generic base class through multiple inheritance (2) (#9660) - restricts type with included module restricts type with included module - restricts module through generic include (#4287) restricts module through generic include (#4287) - restricts virtual generic class against uninstantiated generic subclass (1) restricts virtual generic class against uninstantiated generic subclass (1) - restricts type with same type restricts type with same type - restricts generic module instance with another module restricts generic module instance with another module - restricts type with another type restricts type with another type - restricts type with superclass restricts type with superclass - restricts generic module instance with class restricts generic module instance with class - restricts virtual type with included module 1 restricts virtual type with included module 1 - restricts module with another module restricts module with another module - restricts virtual type with included module 2 restricts virtual type with included module 2 - restricts class against uninstantiated generic base class through multiple inheritance (1) (#9660) restricts class against uninstantiated generic base class through multiple inheritance (1) (#9660) - restricts virtual generic class against uninstantiated generic subclass (2) restricts virtual generic class against uninstantiated generic subclass (2) - passes #278 passes #278 - works with static array that uses underscore works with static array that uses underscore - works with union against unions of generics works with union against unions of generics - sets number as unbound generic type var (#13110) sets number as unbound generic type var (#13110) - errors if using typeof inside generic type errors if using typeof inside generic type - errors on T::Type that's union when used from type restriction errors on T::Type that's union when used from type restriction - errors if using NamedTuple with positional args errors if using NamedTuple with positional args - errors if using Tuple with named args errors if using Tuple with named args - should not let GenericChild(Base) pass as a GenericBase(Child) (#1294) should not let GenericChild(Base) pass as a GenericBase(Child) (#1294) - restricts aliased typedef type (#9474) restricts aliased typedef type (#9474) - does not treat single path as free variable when given number (1) (#11859) does not treat single path as free variable when given number (1) (#11859) - works with generic class metaclass vs. generic instance class metaclass works with generic class metaclass vs. generic instance class metaclass - errors if using typeof errors if using typeof - restriction_of? - GenericClassType vs GenericClassInstanceType - doesn't mix different generic classes doesn't mix different generic classes - works with classes in different namespaces works with classes in different namespaces - keeps GenericClassInstanceType before GenericClassType keeps GenericClassInstanceType before GenericClassType - inserts GenericClassInstanceType before GenericClassType inserts GenericClassInstanceType before GenericClassType - Metaclass vs Path - inserts metaclass before Value inserts metaclass before Value - doesn't error if path is undefined and method is not called (2) (#12516) doesn't error if path is undefined and method is not called (2) (#12516) - keeps metaclass before Class keeps metaclass before Class - keeps metaclass before Value keeps metaclass before Value - keeps metaclass before Object keeps metaclass before Object - inserts metaclass before Object inserts metaclass before Object - doesn't error if path is undefined and method is not called (1) (#12516) doesn't error if path is undefined and method is not called (1) (#12516) - inserts metaclass before Class inserts metaclass before Class - NamedTuple vs NamedTuple - inserts more specialized NamedTuple before less specialized one inserts more specialized NamedTuple before less specialized one - doesn't mix incompatible NamedTuples (#10238) doesn't mix incompatible NamedTuples (#10238) - keeps more specialized NamedTuple before less specialized one keeps more specialized NamedTuple before less specialized one - Union - handles redefinitions (1) (#12330) handles redefinitions (1) (#12330) - orders union before generic (#12330) orders union before generic (#12330) - handles redefinitions (2) (#12330) handles redefinitions (2) (#12330) - free variables - inserts path before free variable with same name inserts path before free variable with same name - keeps path before free variable even if free var resolves to a more specialized type keeps path before free variable even if free var resolves to a more specialized type - inserts constant before free variable with same name inserts constant before free variable with same name - keeps constant before free variable with same name keeps constant before free variable with same name - keeps path before free variable with same name keeps path before free variable with same name - inserts path before free variable even if free var resolves to a more specialized type inserts path before free variable even if free var resolves to a more specialized type - Path vs NumberLiteral - inserts constant before number literal of same value with generic arguments inserts constant before number literal of same value with generic arguments - inserts number literal before constant of same value with generic arguments inserts number literal before constant of same value with generic arguments - Underscore vs Path - keeps underscore after Path (#12854) keeps underscore after Path (#12854) - works with splats and modules, under -Dpreview_overload_order (#12854) works with splats and modules, under -Dpreview_overload_order (#12854) - inserts Path before underscore (#12854) inserts Path before underscore (#12854) - Path vs Path - keeps typed Path before untyped Path keeps typed Path before untyped Path - inserts typed Path before untyped Path inserts typed Path before untyped Path - Metaclass vs Metaclass - inserts typed Metaclass before untyped Metaclass inserts typed Metaclass before untyped Metaclass - keeps typed Metaclass before untyped Metaclass keeps typed Metaclass before untyped Metaclass - Generic vs Path - inserts untyped Generic before untyped Path inserts untyped Generic before untyped Path - inserts typed Generic before untyped Path inserts typed Generic before untyped Path - keeps untyped Generic before untyped Path keeps untyped Generic before untyped Path - inserts untyped Generic before untyped Path (2) inserts untyped Generic before untyped Path (2) - keeps typed Generic before untyped Path keeps typed Generic before untyped Path - Generic vs Generic - keeps typed Generic before untyped Generic keeps typed Generic before untyped Generic - inserts typed Generic before untyped Generic inserts typed Generic before untyped Generic - errors if using free var without forall errors if using free var without forall - works with static array (#637) works with static array (#637) - doesn't error if using NamedTuple with no args doesn't error if using NamedTuple with no args - does not treat single path as free variable when given number (2) (#11859) does not treat single path as free variable when given number (2) (#11859) - self always matches instance type in return type self always matches instance type in return type - matches free variable for type variable matches free variable for type variable - doesn't error if using Tuple with no args doesn't error if using Tuple with no args - makes metaclass subclass pass parent metaclass restriction (#2079) makes metaclass subclass pass parent metaclass restriction (#2079) - matches alias against alias in block type matches alias against alias in block type - allows passing recursive type to free var (#1076) allows passing recursive type to free var (#1076) - matches virtual type against alias matches virtual type against alias - works with generic compared to fixed (primitive) type works with generic compared to fixed (primitive) type - restricts virtual metaclass type against metaclass (#3438) restricts virtual metaclass type against metaclass (#3438) - errors if can't find type on lookup errors if can't find type on lookup - works with generic class metaclass vs. generic class metaclass works with generic class metaclass vs. generic class metaclass - errors if using typeof in block restriction errors if using typeof in block restriction -Crystal::Repl::Interpreter - control flow - interprets next inside while interprets next inside while - interprets next inside while inside block interprets next inside while inside block - interprets if bool (false) interprets if bool (false) - interprets if (nil literal) interprets if (nil literal) - interprets if (true literal) interprets if (true literal) - interprets break with value inside while (through break) interprets break with value inside while (through break) - interprets while interprets while - interprets if bool (true) interprets if bool (true) - interprets return Nil interprets return Nil - interprets break inside nested while interprets break inside nested while - interprets if (nil type) interprets if (nil type) - interprets if union type with bool, true interprets if union type with bool, true - interprets break inside while interprets break inside while - discards if discards if - interprets unless interprets unless - interprets if pointer, false interprets if pointer, false - interprets while, returns nil interprets while, returns nil - interprets return implicit nil and Int32 interprets return implicit nil and Int32 - discards while discards while - interprets if pointer, true interprets if pointer, true - interprets if union type with nil, false interprets if union type with nil, false - interprets break with value inside while (through normal flow) interprets break with value inside while (through normal flow) - interprets if (int type) interprets if (int type) - interprets break inside while inside block interprets break inside while inside block - interprets until interprets until - interprets if (false literal) interprets if (false literal) - interprets if union type with bool, false interprets if union type with bool, false - interprets return interprets return - interprets return Nil with explicit return (#12178) interprets return Nil with explicit return (#12178) -Semantic: if - restricts && of !var.is_a(...) restricts && of !var.is_a(...) - types an if with else of different type types an if with else of different type - doesn't filter and recombine when variables don't change in if doesn't filter and recombine when variables don't change in if - restricts && else in sub && (right) restricts && else in sub && (right) - restricts type with !var.is_a?(...) and && restricts type with !var.is_a?(...) and && - errors if requires inside if errors if requires inside if - types an if without else types an if without else - restricts || else (1) (#3266) restricts || else (1) (#3266) - doesn't consider nil type in else branch with if with && (#7434) doesn't consider nil type in else branch with if with && (#7434) - restricts || else (3) (#3266) restricts || else (3) (#3266) - can invoke method on var that is declared on the right hand side of an and can invoke method on var that is declared on the right hand side of an and - types `if` with `&&` and assignment types `if` with `&&` and assignment - correctly filters type of variable if there's a raise with an interpolation that can't be typed correctly filters type of variable if there's a raise with an interpolation that can't be typed - restricts && else in sub && (left) restricts && else in sub && (left) - restricts || else (2) (#3266) restricts || else (2) (#3266) - types variable after unreachable else of && (#3360) types variable after unreachable else of && (#3360) - restricts with && always falsey restricts with && always falsey - doesn't fail on new variables inside typeof condition doesn't fail on new variables inside typeof condition - doesn't fail on Expressions condition (1) doesn't fail on Expressions condition (1) - restricts with || but doesn't unify types to base class restricts with || but doesn't unify types to base class - restricts type with !var.is_a?(...) and || restricts type with !var.is_a?(...) and || - doesn't restrict || else in sub && (left) doesn't restrict || else in sub && (left) - restricts the type of the right hand side of an || when using is_a? (#1728) restricts the type of the right hand side of an || when using is_a? (#1728) - doesn't restrict || else in sub && (right) doesn't restrict || else in sub && (right) - types an if with else of same type types an if with else of same type - restricts || else in sub || (left) restricts || else in sub || (left) - passes bug (related to #1729) passes bug (related to #1729) - restricts || of more than 2 clauses (#8864) restricts || of more than 2 clauses (#8864) - includes pointer types in falsey branch includes pointer types in falsey branch - doesn't restrict with || on var and non-restricting condition doesn't restrict with || on var and non-restricting condition - restricts with || (#2464) restricts with || (#2464) - doesn't restrict with || on different vars doesn't restrict with || on different vars - restricts type with !var and || restricts type with !var and || - restricts || else in sub || (right) restricts || else in sub || (right) - doesn't fail on nested conditionals inside typeof condition doesn't fail on nested conditionals inside typeof condition - doesn't fail on Expressions condition (2) doesn't fail on Expressions condition (2) - restricts and doesn't unify union types restricts and doesn't unify union types -Lexer: location - stores column numbers stores column numbers - locations in same files are comparable based on line locations in same files are comparable based on line - uses two consecutive loc pragma uses two consecutive loc pragma - Location.parse - parses location from string parses location from string - raises ArgumentError if line number is invalid raises ArgumentError if line number is invalid - raises ArgumentError if missing colon raises ArgumentError if missing colon - raises ArgumentError if missing part raises ArgumentError if missing part - raises ArgumentError if column number is invalid raises ArgumentError if column number is invalid - locations with virtual files should be comparable locations with virtual files should be comparable - stores line numbers stores line numbers - overrides location with pragma overrides location with pragma - assigns correct loc location to node assigns correct loc location to node - parses var/call right after loc (#491) parses var/call right after loc (#491) - locations in different files have no order locations in different files have no order - pushes and pops its location pushes and pops its location -Codegen: class var - codegens class var as nil if assigned for the first time inside method codegens class var as nil if assigned for the first time inside method - reads class var from virtual type metaclass reads class var from virtual type metaclass - codegens class var codegens class var - codegens generic class with class var codegens generic class with class var - initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it initializes class var the moment it reaches it - reads class var before initializing it (hoisting) reads class var before initializing it (hoisting) - uses var in class var initializer uses var in class var initializer - codegens class var with nilable reference type codegens class var with nilable reference type - reads class var from virtual type reads class var from virtual type - doesn't inherit class var value in subclass doesn't inherit class var value in subclass - gets pointerof class var gets pointerof class var - inline initialization of simple class var inline initialization of simple class var - initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var initializes dependent constant before class var - doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module doesn't crash with pointerof from another module - accesses class var from proc literal accesses class var from proc literal - reads simple class var before another complex one reads simple class var before another complex one - codegens class var with begin and vars codegens class var with begin and vars - declares var as uninitialized and initializes it unsafely declares var as uninitialized and initializes it unsafely - initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal initializes class var with array literal - initializes class var of union with single type initializes class var of union with single type - codegens class var inside module codegens class var inside module - codegens class var with type declaration begin and vars codegens class var with type declaration begin and vars - declares and initializes declares and initializes - codegens class var as nil codegens class var as nil - runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) runs class var side effects (#8862) - gets pointerof class var complex constant gets pointerof class var complex constant - catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer catch infinite loop in class var initializer - doesn't inherit class var value in module doesn't inherit class var value in module - codegens class var inside instance method codegens class var inside instance method - doesn't use nilable type for initializer doesn't use nilable type for initializer - doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) doesn't error if class var shares name with const (#7865) - writes class var from virtual type writes class var from virtual type - codegens second class var initializer codegens second class var initializer -Semantic: not - types not types not - filters types inside if/else filters types inside if/else - filters types with !is_a? filters types with !is_a? - filters types inside if filters types inside if - doesn't restrict and in while (#4243) doesn't restrict and in while (#4243) - doesn't restrict and doesn't restrict and - types not as NoReturn if exp is NoReturn types not as NoReturn if exp is NoReturn -Code gen: exception - can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) can use argument in rescue, with a different type (1) (#2844) - executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) executes ensure when no exception is raised (2) - executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) executes ensure when exception is raised (1) - executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure executes return inside rescue, executing ensure - executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target - handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) handle multiple exception types (1) - handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) handles exception in outer block (2) - handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal handle exception raised by proc literal - can result into union (2) can result into union (2) can result into union (2) can result into union (2) can result into union (2) can result into union (2) can result into union (2) can result into union (2) can result into union (2) can result into union (2) - doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) doesn't execute else if exception is raised conditionally (2) - codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return codegens exception handler with return - handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type handles rescuing union between module type and class type - doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) doesn't execute else if exception is raised conditionally (1) - executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block executes ensure of break inside block - doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 doesn't crash on #1988 - types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) types parenthesized expression (#5511) - executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) executes ensure when no exception is raised (1) - can result into union (1) can result into union (1) can result into union (1) can result into union (1) can result into union (1) can result into union (1) can result into union (1) can result into union (1) can result into union (1) can result into union (1) - executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block executes ensure of break inside while inside body with block - codegens issue #118 (1) codegens issue #118 (1) - doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) doesn't execute else if exception is raised (2) - captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc captures exception thrown from proc - catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) catches exception thrown by as inside method (#4030) - executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) executes ensure when exception is unhandled (2) - handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) handles exception in outer block (1) - uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue uses exception after rescue - executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue executes ensure of break inside while inside rescue - executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns - handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types handles rescuing union between module types - executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) executes else if no exception is raised (1) - executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) executes body if nothing raised (1) - doesn't codegen duplicated ensure if unreachable (#709) doesn't codegen duplicated ensure if unreachable (#709) - executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body executes ensure of next inside while inside body - executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns executes ensure when the main block returns - handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions handles nested exceptions - receives exception object receives exception object receives exception object receives exception object receives exception object receives exception object receives exception object receives exception object receives exception object receives exception object - executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) executes ensure when exception is unhandled (1) - executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) executes ensure of calling method when doing break inside block (#1233) - handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type handles rescuing module type - does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union does not rescue just any union - executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) executes ensure when exception is raised (2) - executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns executes ensure when the main block yields and returns - executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block - closures rescue variable (#8141) closures rescue variable (#8141) - executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers executes ensure of break inside while inside body with nested handlers - rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue rescues with types defaults to generic rescue - handles subclass handles subclass handles subclass handles subclass handles subclass handles subclass handles subclass handles subclass handles subclass handles subclass - runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) runs NoReturn ensure (#3082) - codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value codegens return from rescue with value - rescues with type rescues with type rescues with type rescues with type rescues with type rescues with type rescues with type rescues with type rescues with type rescues with type - propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) propagates raise status (#2074) - executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue executes ensure when raising inside rescue - executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally executes rescue if something is raised conditionally - executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) executes else if no exception is raised (2) - can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) can use argument in rescue, with a different type (2) (#2844) - executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally executes rescue if something is raised unconditionally - can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) can rescue TypeCastError (#2607) - does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) does ensure after rescue which returns (#171) - handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) handle multiple exception types (2) - does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module does not rescue just any module - rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union rescues a valid nested union - executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target executes ensure from return until target - codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception codegens rescue specific leaf exception - ensure without rescue ensure without rescue ensure without rescue ensure without rescue ensure without rescue ensure without rescue ensure without rescue ensure without rescue ensure without rescue ensure without rescue - rescues a valid union rescues a valid union rescues a valid union rescues a valid union rescues a valid union rescues a valid union rescues a valid union rescues a valid union rescues a valid union rescues a valid union - codegens issue #118 (2) codegens issue #118 (2) - executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block executes ensure of next inside block - can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) can use argument in rescue (#2844) - runs #2441 runs #2441 runs #2441 runs #2441 runs #2441 runs #2441 runs #2441 runs #2441 runs #2441 runs #2441 - doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) doesn't execute else if exception is raised (1) - executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else executes ensure of break inside while inside else - executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body executes ensure of break inside while inside body -Code gen: ssa - codegens declaration of var inside then when true codegens declaration of var inside then when true - codegens a var that is re-assigned in a block (1) codegens a var that is re-assigned in a block (1) - codegens a var that is declared in a block (1) codegens a var that is declared in a block (1) - codegens a var that is re-assigned in a block codegens a var that is re-assigned in a block - codegens a var that is declared in a block (2) codegens a var that is declared in a block (2) - codegens a redefined var codegens a redefined var - codegens ssa bug with if/else on var codegens ssa bug with if/else on var - codegens a var that is re-assigned in a block (2) codegens a var that is re-assigned in a block (2) - codegens ssa bug (1) codegens ssa bug (1) - codegens a redefined var inside method codegens a redefined var inside method - codegens a redefined var inside method with argument codegens a redefined var inside method with argument - codegens ssa bug (2) codegens ssa bug (2) - codegens declaration of var inside then when false codegens declaration of var inside then when false -Crystal::Init::InitProject - correctly uses git config correctly uses git config - has proper contents has proper contents + does to_s of "asm(\"nop\" :::: \"volatile\")" does to_s of "asm(\"nop\" :::: \"volatile\")" + does to_s of "{(1 + 2) => (3 + 4)}" does to_s of "{(1 + 2) => (3 + 4)}" + does to_s of "def foo(x y)\nend" does to_s of "def foo(x y)\nend" + does to_s of "(1 + 2)..3" does to_s of "(1 + 2)..3" + does to_s of "def foo(x, **args)\nend" does to_s of "def foo(x, **args)\nend" + does to_s of "macro foo(*, __var var)\nend" does to_s of "macro foo(*, __var var)\nend" + does to_s of "1 <= 2 <= 3" does to_s of "1 <= 2 <= 3" + does to_s of "{ {1 => 2} }" does to_s of "{ {1 => 2} }" + does to_s of "lib LibC\n fun getchar(Int, Float)\nend" does to_s of "lib LibC\n fun getchar(Int, Float)\nend" + does to_s of "foo(x : (T -> U) | V)" does to_s of "foo(x : (T -> U) | V)" + does to_s of "1 <= (2 <= 3)" does to_s of "1 <= (2 <= 3)" + does to_s of "1.[]=" does to_s of "1.[]=" + does to_s of "(1..)" does to_s of "(1..)" + does to_s of "case 1; when .!; 2; when .< 0; 3; end" does to_s of "case 1; when .!; 2; when .< 0; 3; end" + does to_s of "foo.%" does to_s of "foo.%" + does to_s of "foo(1, (2 + 3), bar: (4 + 5))" does to_s of "foo(1, (2 + 3), bar: (4 + 5))" + does to_s of "1.&*" does to_s of "1.&*" + does to_s of "asm(\"nop\" :: \"a\"(1) :: \"volatile\")" does to_s of "asm(\"nop\" :: \"a\"(1) :: \"volatile\")" + does to_s of "foo[x, y, a: 1, b: 2]" does to_s of "foo[x, y, a: 1, b: 2]" + does to_s of "macro foo(x, *y)\nend" does to_s of "macro foo(x, *y)\nend" + does to_s of "{% for foo in bar %}\n {{ if true\n foo\n bar\nend }}\n{% end %}" does to_s of "{% for foo in bar %}\n {{ if true\n foo\n bar\nend }}\n{% end %}" + does to_s of "macro foo(@[Foo] x, @[Foo] *y)\nend" does to_s of "macro foo(@[Foo] x, @[Foo] *y)\nend" + does to_s of "foo._bar" does to_s of "foo._bar" +.parse_args + DIR (relative to home) DIR (relative to home) + NAME DIR NAME DIR + DIR DIR + DIR (absolute) DIR (absolute) + DIR with path DIR with path + DIR = . DIR = . +Semantic: external/internal + macros + can call with external name and use with internal, after splat can call with external name and use with internal, after splat + can call with external name and use with internal can call with external name and use with internal + can call positionally can call positionally + overloads based on external name (#2610) overloads based on external name (#2610) + can call with external name and use with internal can call with external name and use with internal + can call with external name and use with internal, after splat can call with external name and use with internal, after splat + can call positionally can call positionally +Semantic: alias + can use .class in alias (#2835) can use .class in alias (#2835) + inherits class through alias inherits class through alias + can pass recursive alias to proc can pass recursive alias to proc + allows defining recursive aliases allows defining recursive aliases + allows recursive array with alias allows recursive array with alias + errors if trying to resolve type of recursive alias errors if trying to resolve type of recursive alias + resolves alias type resolves alias type + finds type through alias (#4645) finds type through alias (#4645) + errors if alias is already defined as another type errors if alias is already defined as another type + reopens module through alias within itself reopens module through alias within itself + errors if trying to use typeof in alias errors if trying to use typeof in alias + errors if defining infinite recursive alias in union errors if defining infinite recursive alias in union + resolves type through alias (#563) resolves type through alias (#563) + allows using alias type as generic type allows using alias type as generic type + looks up alias for macro resolution (#3548) looks up alias for macro resolution (#3548) + errors if alias already defined errors if alias already defined + reopens struct through alias reopens struct through alias + declares alias inside type declares alias inside type + reopens struct through alias within itself reopens struct through alias within itself + uses constant in alias (#3259) uses constant in alias (#3259) + allows using generic type of recursive alias as restriction (#488) allows using generic type of recursive alias as restriction (#488) + doesn't crash by infinite recursion against type alias and generics (#5329) doesn't crash by infinite recursion against type alias and generics (#5329) + overloads union type through alias overloads union type through alias + includes module through alias includes module through alias + allows defining recursive fun aliases allows defining recursive fun aliases + works with alias type as restriction works with alias type as restriction + inherits struct through alias inherits struct through alias + reopens class through alias within itself reopens class through alias within itself + doesn't find type parameter in alias (#3502) doesn't find type parameter in alias (#3502) + uses constant in alias with math (#3259) uses constant in alias with math (#3259) + reopens module through alias reopens module through alias + errors if declares alias inside if errors if declares alias inside if + errors if defining infinite recursive alias errors if defining infinite recursive alias + reopens class through alias reopens class through alias Semantic: hooks - does inherited macro does inherited macro + types macro finished hook bug regarding initialize (#3964) types macro finished hook bug regarding initialize (#3964) does inherited macro for generic class does inherited macro for generic class - does included macro does included macro - does extended macro does extended macro - errors if wrong extended params size errors if wrong extended params size - does included macro for generic module does included macro for generic module - errors if wrong finished params length errors if wrong finished params length does added method macro does added method macro - types initializer in inherited types initializer in inherited - includes error message in included hook (#889) includes error message in included hook (#889) - does inherited macro through generic instance type (#9693) does inherited macro through generic instance type (#9693) - types macro finished hook bug regarding initialize (#3964) types macro finished hook bug regarding initialize (#3964) - errors if wrong extended params length errors if wrong extended params length - errors if wrong inherited params size errors if wrong inherited params size - errors if wrong included params size errors if wrong included params size + errors if wrong finished params length errors if wrong finished params length does not invoke 'method_added' hook recursively does not invoke 'method_added' hook recursively -Crystal::Repl::Interpreter - is_a? - does is_a? from NilableType to NonGenericClassType (true) does is_a? from NilableType to NonGenericClassType (true) - does is_a? from NilableReferenceUnionType to NonGenericClassType (false) does is_a? from NilableReferenceUnionType to NonGenericClassType (false) - does is_a? from NilableReferenceUnionType to NonGenericClassType (true) does is_a? from NilableReferenceUnionType to NonGenericClassType (true) - does is_a? from NilableType to NonGenericClassType (false) does is_a? from NilableType to NonGenericClassType (false) - does is_a? from VirtualType to NonGenericClassType (false) does is_a? from VirtualType to NonGenericClassType (false) - does is_a? from NilableType to GenericClassInstanceType (false) does is_a? from NilableType to GenericClassInstanceType (false) - does is_a? from NilableProcType to non-Nil does is_a? from NilableProcType to non-Nil - does is_a? from NilableType to GenericClassInstanceType (true) does is_a? from NilableType to GenericClassInstanceType (true) - does is_a? from NilableProcType to Nil does is_a? from NilableProcType to Nil - does is_a? from VirtualType to NonGenericClassType (true) does is_a? from VirtualType to NonGenericClassType (true) -Crystal::FFI::CallInterface - .new - sum struct sum struct - all primitive arg types all primitive arg types - simple call simple call - array array - make struct make struct - with args with args - .variadic - basic basic - zero varargs zero varargs - validates args size validates args size -Crystal::Repl::Interpreter - bugs - does multidispatch on virtual struct does multidispatch on virtual struct - does multidispatch on virtual struct union nil does multidispatch on virtual struct union nil - correctly puts virtual metaclass type in union correctly puts virtual metaclass type in union - doesn't pass self to top-level method doesn't pass self to top-level method - does leading zeros does leading zeros - doesn't pass self to top-level method (FileNode) doesn't pass self to top-level method (FileNode) - doesn't override local variable value with block var with the same name doesn't override local variable value with block var with the same name - breaks from current block, not from outer block breaks from current block, not from outer block - doesn't incorrectly consider a non-closure as closure doesn't incorrectly consider a non-closure as closure -Semantic: struct - errors if invoking to_unsafe and got different type errors if invoking to_unsafe and got different type - errors if invoking to_i32! and got wrong type errors if invoking to_i32! and got wrong type - can access instance var from the outside (#1092) can access instance var from the outside (#1092) - errors if already defined with another type errors if already defined with another type - errors if includes and field already exists errors if includes and field already exists - types struct getter multiple levels via new types struct getter multiple levels via new - errors if invoking to_unsafe and got error in that call errors if invoking to_unsafe and got error in that call - automatically converts numeric type in struct field assignment automatically converts numeric type in struct field assignment - errors if using void via typedef in struct field type errors if using void via typedef in struct field type - errors on struct setter if different type via new errors on struct setter if different type via new - errors on struct setter if different type errors on struct setter if different type - types struct getter to struct types struct getter to struct - errors on struct if no field errors on struct if no field - errors if includes and field already exists, the other way around errors if includes and field already exists, the other way around - errors if setting closure errors if setting closure - supports macro if inside struct supports macro if inside struct - types Struct#new types Struct#new - types struct setter types struct setter - marks as packed marks as packed - types struct types struct - errors if already defined with another type (2) errors if already defined with another type (2) - types struct getter types struct getter - errors on empty c struct (#633) errors on empty c struct (#633) - errors if using void in struct field type errors if using void in struct field type - includes another struct includes another struct - errors if includes non-cstruct type errors if includes non-cstruct type - errors if includes unknown type errors if includes unknown type - errors if invoking to_i32! and got error in that call errors if invoking to_i32! and got error in that call - types struct getter on pointer type types struct getter on pointer type - errors if already defined errors if already defined - allows inline forward declaration allows inline forward declaration - types struct getter with keyword name types struct getter with keyword name -Normalize: op assign - normalizes exp[value] &&= normalizes exp[value] &&= - normalizes var += normalizes var += - normalizes exp[value] += normalizes exp[value] += - normalizes var &&= normalizes var &&= - normalizes var -= normalizes var -= - normalizes exp.value ||= normalizes exp.value ||= - normalizes var &+= normalizes var &+= - normalizes exp.value &&= normalizes exp.value &&= - normalizes var.value += normalizes var.value += - normalizes var &-= normalizes var &-= - normalizes @@var[0] += normalizes @@var[0] += - normalizes @@var.value += normalizes @@var.value += - normalizes @var[0] += normalizes @var[0] += - normalizes exp[value] ||= normalizes exp[value] ||= - normalizes var ||= normalizes var ||= - normalizes exp[0] += normalizes exp[0] += - normalizes var[0] += normalizes var[0] += - normalizes var &*= normalizes var &*= - normalizes exp.value += normalizes exp.value += - normalizes @var.value += normalizes @var.value += - normalizes var *= normalizes var *= -Code gen: hash literal spec - creates custom generic hash in module (#5684) creates custom generic hash in module (#5684) - creates custom generic hash via alias (1) creates custom generic hash via alias (1) - creates custom generic hash via alias (2) creates custom generic hash via alias (2) - creates custom generic hash creates custom generic hash - creates custom non-generic hash in module creates custom non-generic hash in module - creates custom generic hash with type vars creates custom generic hash with type vars - assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works - assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works - creates custom non-generic hash creates custom non-generic hash - doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) -Crystal::Repl::Interpreter - unions - converts from NilableType to NonGenericClassType converts from NilableType to NonGenericClassType - put and remove from union in instance var put and remove from union in instance var - put and remove from union in local var put and remove from union in local var - returns large union type (#15041) returns large union type (#15041) - put and remove from union, together with is_a? (truthy case) put and remove from union, together with is_a? (truthy case) - returns union type returns union type - puts union inside union puts union inside union - discards is_a? discards is_a? - put and remove from union, together with is_a? (falsey case) put and remove from union, together with is_a? (falsey case) -Semantic: super - finds super initialize if not explicitly defined in superclass, 2 (#273) finds super initialize if not explicitly defined in superclass, 2 (#273) - gives correct error when calling super and target is abstract method (#2675) gives correct error when calling super and target is abstract method (#2675) - types super when inside fun and forwards args types super when inside fun and forwards args - types super with named arguments, def has bare splat parameter (#8895) types super with named arguments, def has bare splat parameter (#8895) - errors no superclass method in top-level errors no superclass method in top-level - calls super in module method (2) (#556) calls super in module method (2) (#556) - types super without arguments types super without arguments - types super when inside fun types super when inside fun - types super with forwarded arguments, different internal names (#8895) types super with forwarded arguments, different internal names (#8895) - calls super in module method (3) (#556) calls super in module method (3) (#556) - types super with forwarded arguments, def has bare splat parameter (#8895) types super with forwarded arguments, def has bare splat parameter (#8895) - calls super in module method (1) (#556) calls super in module method (1) (#556) - errors if invoking super and match isn't found in direct superclass in initialize (even though it's find in one superclass) errors if invoking super and match isn't found in direct superclass in initialize (even though it's find in one superclass) - says correct error message when no overload matches in super call (#272) says correct error message when no overload matches in super call (#272) - finds super initialize if not explicitly defined in superclass, 1 (#273) finds super initialize if not explicitly defined in superclass, 1 (#273) - errors on super where only target would be a top level method (#5201) errors on super where only target would be a top level method (#5201) - types super with forwarded arguments, parent has parameters types super with forwarded arguments, parent has parameters - errors on super outside method (#4481) errors on super outside method (#4481) - types super when container method is defined in parent class types super when container method is defined in parent class - doesn't error if invoking super and match isn't found in direct superclass (even though it's find in one superclass) doesn't error if invoking super and match isn't found in direct superclass (even though it's find in one superclass) - calls super in generic module method calls super in generic module method - types super without arguments and instance variable types super without arguments and instance variable - invokes super inside macro (#6636) invokes super inside macro (#6636) - errors no superclass method in top-level def errors no superclass method in top-level def - types super when container method is defined in parent class two levels up types super when container method is defined in parent class two levels up - types super with named arguments, def has bare splat parameter (2) (#8895) types super with named arguments, def has bare splat parameter (2) (#8895) - types super with forwarded arguments, def has double splat parameter (#8895) types super with forwarded arguments, def has double splat parameter (#8895) - errors if calling super on module method and not found errors if calling super on module method and not found - errors no superclass method errors no superclass method -Semantic: generic class - errors if using Float in a generic type errors if using Float in a generic type - inherits from generic with forwarding (2) inherits from generic with forwarding (2) - never types Generic as virtual outside generic type parameter (#3989) never types Generic as virtual outside generic type parameter (#3989) - instantiates generic variadic class, accesses T from instance method through superclass instantiates generic variadic class, accesses T from instance method through superclass - initializes instance variable of generic type using type var (#961) initializes instance variable of generic type using type var (#961) - can define instance var forward declared (#962) can define instance var forward declared (#962) - allows initializing instance variable in inherited generic type allows initializing instance variable in inherited generic type - instantiates generic variadic class, accesses T from instance method through superclass, more args instantiates generic variadic class, accesses T from instance method through superclass, more args - restricts non-generic to generic with free var restricts non-generic to generic with free var - replaces type parameters in virtual metaclasses (#10691) replaces type parameters in virtual metaclasses (#10691) - never types Path as virtual outside generic type parameter (#3989) never types Path as virtual outside generic type parameter (#3989) - errors if passing integer literal to Tuple as generic argument (#1120) errors if passing integer literal to Tuple as generic argument (#1120) - restricts generic type argument through alias in a non-strict way restricts generic type argument through alias in a non-strict way - instantiates generic variadic class, accesses T from class method through superclass instantiates generic variadic class, accesses T from class method through superclass - restricts virtual generic instance type against generic (#3351) restricts virtual generic instance type against generic (#3351) - creates pointer of generic type and uses it (2) creates pointer of generic type and uses it (2) - doesn't crash when matching restriction against number literal (2) (#3157) doesn't crash when matching restriction against number literal (2) (#3157) - errors if inheriting from generic and incorrect number of type vars errors if inheriting from generic and incorrect number of type vars - unifies generic metaclass types unifies generic metaclass types - restricts generic to generic with free var restricts generic to generic with free var - restricts non-generic to generic restricts non-generic to generic - errors if using Class in a generic type errors if using Class in a generic type - recomputes on new subclass recomputes on new subclass - errors if using Pointer in a generic type errors if using Pointer in a generic type - instantiates generic variadic class, accesses T from class method instantiates generic variadic class, accesses T from class method - errors if inheriting generic type and not specifying type vars (#460) errors if inheriting generic type and not specifying type vars (#460) - errors if using Tuple in a generic type errors if using Tuple in a generic type - nests generics with the same type var (#3297) nests generics with the same type var (#3297) - splats generic type var splats generic type var - disallow using a non-instantiated generic type as a generic type argument disallow using a non-instantiated generic type as a generic type argument - allows T::Type with T a generic type allows T::Type with T a generic type - inherits non-generic to generic (2) inherits non-generic to generic (2) - can use type var that resolves to number in restriction (#6502) can use type var that resolves to number in restriction (#6502) - finds generic type argument from method with default value finds generic type argument from method with default value - inherits non-generic to generic (1) inherits non-generic to generic (1) - errors if using Enum in a generic type errors if using Enum in a generic type - inherits instance var type annotation from generic to concrete with T inherits instance var type annotation from generic to concrete with T - errors if splatting a non-tuple (#9853) errors if splatting a non-tuple (#9853) - instantiates generic variadic class, accesses T from instance method, more args instantiates generic variadic class, accesses T from instance method, more args - subclasses twice with same generic class (#3423) subclasses twice with same generic class (#3423) - errors if using Struct in a generic type errors if using Struct in a generic type - errors if using Proc in a generic type errors if using Proc in a generic type - doesn't compute generic instance var initializers in formal superclass's context (#4753) doesn't compute generic instance var initializers in formal superclass's context (#4753) - defines empty initialize on inherited generic class defines empty initialize on inherited generic class - doesn't find T type parameter of current type in superclass (#4604) doesn't find T type parameter of current type in superclass (#4604) - correctly checks argument count when target type has a splat (#9855) correctly checks argument count when target type has a splat (#9855) - shows error due to generic instantiation (#7083) shows error due to generic instantiation (#7083) - doesn't crash when matching restriction against number literal (#3157) doesn't crash when matching restriction against number literal (#3157) - errors if using StaticArray in a generic type errors if using StaticArray in a generic type - errors if inheriting from generic when it is non-generic errors if inheriting from generic when it is non-generic - replaces type parameters for virtual types (#3235) replaces type parameters for virtual types (#3235) - errors if using Object in a generic type errors if using Object in a generic type - creates pointer of generic type and uses it creates pointer of generic type and uses it - can use type var that resolves to number in restriction using Int128 can use type var that resolves to number in restriction using Int128 - inherits from generic with instantiation inherits from generic with instantiation - instantiates generic variadic class, accesses T from instance method instantiates generic variadic class, accesses T from instance method - errors if using Value in a generic type errors if using Value in a generic type - inherits from generic with instantiation with instance var inherits from generic with instantiation with instance var - doesn't duplicate overload on generic class with class method (#2385) doesn't duplicate overload on generic class with class method (#2385) - instantiates generic class with default argument in initialize (#394) instantiates generic class with default argument in initialize (#394) - errors if using Int in a generic type errors if using Int in a generic type - allows initializing instance variable (#665) allows initializing instance variable (#665) - inherits from generic with forwarding (1) inherits from generic with forwarding (1) - virtual metaclass type implements super virtual metaclass type (#3007) virtual metaclass type implements super virtual metaclass type (#3007) - resolves T through metaclass inheritance (#7914) resolves T through metaclass inheritance (#7914) - errors if passing integer literal to Proc as generic argument (#1120) errors if passing integer literal to Proc as generic argument (#1120) - errors if using Number in a generic type errors if using Number in a generic type - errors if using Number in recursive alias errors if using Number in recursive alias - instantiates generic variadic class, accesses T from instance method, more args (2) instantiates generic variadic class, accesses T from instance method, more args (2) - error on T::Type with T a generic type that's a union error on T::Type with T a generic type that's a union - doesn't allow union of generic class with module to be assigned to a generic class with module (#2425) doesn't allow union of generic class with module to be assigned to a generic class with module (#2425) - doesn't consider unbound generic instantiations as concrete (#7200) doesn't consider unbound generic instantiations as concrete (#7200) - errors on too nested tuple instance errors on too nested tuple instance - errors on too nested generic instance, with union type errors on too nested generic instance, with union type - inherits twice inherits twice - errors if using Number in alias errors if using Number in alias - calls super on generic type when superclass has no initialize (#933) calls super on generic type when superclass has no initialize (#933) - errors if invoking new on private new in generic type (#3485) errors if invoking new on private new in generic type (#3485) - errors if using Reference in a generic type errors if using Reference in a generic type - errors if passing integer literal to Union as generic argument errors if passing integer literal to Union as generic argument - can use virtual type for generic class can use virtual type for generic class - disallow using a non-instantiated module type as a generic type argument disallow using a non-instantiated module type as a generic type argument - types macro def with generic instance types macro def with generic instance - gives helpful error message when generic type var is missing in block spec (#1526) gives helpful error message when generic type var is missing in block spec (#1526) - gives helpful error message when generic type var is missing (#1526) gives helpful error message when generic type var is missing (#1526) - inherits instance var type annotation from generic to generic to concrete inherits instance var type annotation from generic to generic to concrete - errors on too nested generic instance errors on too nested generic instance - errors if using Number | String in a generic type errors if using Number | String in a generic type - doesn't find unbound type parameter in main code inside generic type (#6168) doesn't find unbound type parameter in main code inside generic type (#6168) - inherits class methods from generic class inherits class methods from generic class - inherits instance var type annotation from generic to concrete inherits instance var type annotation from generic to concrete -Lexer macro - lexes macro with nested if lexes macro with nested if - lexes with if/end inside escaped macro (#1029) lexes with if/end inside escaped macro (#1029) - lexes macro without nested if lexes macro without nested if - lexes macro with semicolon before end lexes macro with semicolon before end - lexes macro with if as suffix after return lexes macro with if as suffix after return - lexes macro with nested until lexes macro with nested until - lexes macro with nested begin lexes macro with nested begin - lexes begin end lexes begin end - lexes macro with embedded string with %[ lexes macro with embedded string with %[ - lexes macro with nested annotation lexes macro with nested annotation - lexes macro with nested struct lexes macro with nested struct - lexes macro with embedded string lexes macro with embedded string - lexes macro with embedded string with %< ignores begin lexes macro with embedded string with %< ignores begin - lexes macro with nested unless lexes macro with nested unless - lexes macro with curly escape in comment lexes macro with curly escape in comment - lexes macro with nested enum lexes macro with nested enum - lexes with unless inside escaped macro (#5664) lexes with unless inside escaped macro (#5664) - lexes macro with embedded string with %< lexes macro with embedded string with %< - lexes macro with nested macro lexes macro with nested macro - lexes macro with string interpolation and double curly brace lexes macro with string interpolation and double curly brace - lexes macro with curly escape lexes macro with curly escape - lexes macro with nested while lexes macro with nested while - keeps correct line number after lexes the part of keyword and newline (#4656) keeps correct line number after lexes the part of keyword and newline (#4656) - lexes macro with nested abstract class lexes macro with nested abstract class - lexes macro with embedded char and sharp lexes macro with embedded char and sharp - lexes macro with nested module lexes macro with nested module - lexes macro with expression lexes macro with expression - lexes macro with nested do lexes macro with nested do - lexes macro with embedded string and backslash lexes macro with embedded string and backslash - lexes macro with nested class lexes macro with nested class - lexes macro with nested abstract def lexes macro with nested abstract def - skips whitespace skips whitespace - lexes simple macro lexes simple macro - doesn't lex macro var if escaped doesn't lex macro var if escaped - lexes macro with embedded string with %( ignores begin lexes macro with embedded string with %( ignores begin - lexes macro with nested fun lexes macro with nested fun - lexes macro with embedded string with %[ ignores begin lexes macro with embedded string with %[ ignores begin - lexes macro with control lexes macro with control - lexes macro with if as suffix lexes macro with if as suffix - lexes macro with comments lexes macro with comments - reaches end reaches end - lexes macro with embedded string with %( lexes macro with embedded string with %( - lexes bug #654 lexes bug #654 - lexes escaped quote inside string (#895) lexes escaped quote inside string (#895) - lexes macro with nested def lexes macro with nested def - lexes macro with nested lib lexes macro with nested lib - lexes macro with nested embedded string with %( lexes macro with nested embedded string with %( - lexes macro var lexes macro var - lexes macro with embedded string and expression lexes macro with embedded string and expression - lexes macro with if after assign lexes macro with if after assign - lexes macro with slash not followed by curly lexes macro with slash not followed by curly - lexes with for inside escaped macro (#1029) lexes with for inside escaped macro (#1029) - lexes macro with nested abstract struct lexes macro with nested abstract struct - lexes macro with comments and expressions lexes macro with comments and expressions - keeps correct column and line numbers keeps correct column and line numbers - lexes macro with nested select lexes macro with nested select - lexes macro with nested union lexes macro with nested union - lexes macro with nested case lexes macro with nested case -Crystal::Playground::Session - assert assert -Code gen: hooks - does added method macro does added method macro - fixes empty types in hooks (#3946) fixes empty types in hooks (#3946) + does inherited macro through generic instance type (#9693) does inherited macro through generic instance type (#9693) + does inherited macro does inherited macro does extended macro does extended macro - does inherited macro recursively does inherited macro recursively - does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body does inherited macro before class body + errors if wrong extended params length errors if wrong extended params length + types initializer in inherited types initializer in inherited does included macro does included macro - does finished does finished - does inherited macro does inherited macro -Semantic: ReferenceStorage - allows a different name allows a different name - errors if T is a nilable type errors if T is a nilable type - errors if T is a union type errors if T is a union type - errors if T is a value type errors if T is a value type - errors if T is a struct type errors if T is a struct type -Crystal::Repl::Interpreter - class vars - does class var initializer with union (#12633) does class var initializer with union (#12633) - reads class var initializer with union (#12633) reads class var initializer with union (#12633) - interprets class var without initializer interprets class var without initializer - interprets class var for virtual type interprets class var for virtual type - interprets class var with initializer interprets class var with initializer - interprets class var for virtual metaclass type interprets class var for virtual metaclass type - finds self in class var initializer (#12439) finds self in class var initializer (#12439) -Code gen: uninitialized - codegens declare instance var with static array type codegens declare instance var with static array type - works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) works inside while/begin/rescue (bug inside #759) - doesn't break on inherited declared var (#390) doesn't break on inherited declared var (#390) - codegens declare var and read it codegens declare var and read it - codegens declare var and changes it codegens declare var and changes it - codegens value (#3641) codegens value (#3641) - works with uninitialized NoReturn (#3314) works with uninitialized NoReturn (#3314) - codegens declare instance var codegens declare instance var + does included macro for generic module does included macro for generic module + errors if wrong included params size errors if wrong included params size + includes error message in included hook (#889) includes error message in included hook (#889) + errors if wrong extended params size errors if wrong extended params size + errors if wrong inherited params size errors if wrong inherited params size +Code gen: return + doesn't crash when method returns nil and can be inlined doesn't crash when method returns nil and can be inlined + codegens return followed by another expression codegens return followed by another expression + returns empty from function returns empty from function + forms a tuple from multiple return values forms a tuple from multiple return values + flattens splats inside multiple return values flattens splats inside multiple return values + return from function with union type return from function with union type + codegens assign with if with two returns codegens assign with if with two returns + codegens bug with return if true codegens bug with return if true + codegens return codegens return + return from function with nilable type return from function with nilable type + return from function with nilable type 2 return from function with nilable type 2 + codegens return inside if codegens return inside if + returns in var assignment (#3364) returns in var assignment (#3364) + return union return union +Crystal::Doc::Type + #instance_methods + sorts operators first sorts operators first + ASTNode has no ancestors ASTNode has no ancestors + #macros + sorts operators first sorts operators first + ASTNode has no superclass ASTNode has no superclass + doesn't show types for alias type doesn't show types for alias type + #node_to_html + shows tuples shows tuples + shows generic path with necessary colons shows generic path with necessary colons + shows relative generic shows relative generic + shows relative path shows relative path + shows generic path with unnecessary colons shows generic path with unnecessary colons + shows named tuples shows named tuples + finds construct when searching class method (#8095) finds construct when searching class method (#8095) + #class_methods + sorts operators first sorts operators first +Code gen: offsetof + returns offset allowing manual access of first class field returns offset allowing manual access of first class field + returns offset of extern union returns offset of extern union + returns offset allowing manual access of struct field that isn't first returns offset allowing manual access of struct field that isn't first + returns offset of `StaticArray#@buffer` returns offset of `StaticArray#@buffer` + returns offset allowing manual access of tuple items returns offset allowing manual access of tuple items + returns offset allowing manual access of first struct field returns offset allowing manual access of first struct field + returns offset allowing manual access of class field that isn't first returns offset allowing manual access of class field that isn't first +Normalize: case + normalizes case with call normalizes case with call + normalizes case with multiple expressions with all underscores normalizes case with multiple expressions with all underscores + normalizes case without value with many expressions in when normalizes case without value with many expressions in when + normalizes case with multiple expressions normalizes case with multiple expressions + normalizes case with multiple expressions and non-tuple normalizes case with multiple expressions and non-tuple + normalizes case with multiple expressions and implicit obj normalizes case with multiple expressions and implicit obj + normalizes case with Path.class to is_a? (in) normalizes case with Path.class to is_a? (in) + normalizes case with Path.class to is_a? normalizes case with Path.class to is_a? + normalizes case with generic to is_a? normalizes case with generic to is_a? + normalizes case with implicit call normalizes case with implicit call + normalizes case with Path to is_a? normalizes case with Path to is_a? + normalizes case with assignment wrapped by paren normalizes case with assignment wrapped by paren + normalizes case without when but else normalizes case without when but else + normalizes case with assignment normalizes case with assignment + normalizes case with Generic.class to is_a? normalizes case with Generic.class to is_a? + normalizes case without value normalizes case without value + normalizes case with implicit ! normalizes case with implicit ! + normalizes case with multiple expressions with all underscores twice normalizes case with multiple expressions with all underscores twice + normalizes case with implicit responds_to? (#3040) normalizes case with implicit responds_to? (#3040) + normalizes case with implicit as? (#3040) normalizes case with implicit as? (#3040) + normalizes case with multiple expressions and types normalizes case with multiple expressions and types + normalizes case without cond, when but else normalizes case without cond, when but else + normalizes case with var in cond normalizes case with var in cond + normalizes case with implicit is_a? (#3040) normalizes case with implicit is_a? (#3040) + normalizes case with multiple expressions with underscore normalizes case with multiple expressions with underscore + normalizes case with implicit as (#3040) normalizes case with implicit as (#3040) + normalizes case with nil to is_a? normalizes case with nil to is_a? + normalizes case without when and else normalizes case without when and else + normalizes case without cond, when and else normalizes case without cond, when and else + normalizes case with many expressions in when normalizes case with many expressions in when + normalizes case with multiple expressions and comma normalizes case with multiple expressions and comma +Crystal::Command::FlagsVisitor + different flags different flags + only macro only macro + unique flags unique flags Code gen: block - codegens bug with yield not_nil! that is never not nil codegens bug with yield not_nil! that is never not nil - codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) - can call methods from block when yielder is an instance method can call methods from block when yielder is an instance method - breaks from while in function called from block breaks from while in function called from block codegens block bug with conditional next and unconditional break (2) codegens block bug with conditional next and unconditional break (2) - yields more exps than block arg, through splat yields more exps than block arg, through splat - return from block called from dispatch return from block called from dispatch + codegens method invocation on a object of a captured block with a type that was never instantiated codegens method invocation on a object of a captured block with a type that was never instantiated + dispatches with captured and non-captured block (#3969) dispatches with captured and non-captured block (#3969) + clears nilable var before inlining block method (#10087) clears nilable var before inlining block method (#10087) + can break without value from yielder that returns nilable (2) can break without value from yielder that returns nilable (2) + codegens block with nilable type with return (2) codegens block with nilable type with return (2) + codegens method invocation on a object of a captured block with a type that was never instantiated (2) codegens method invocation on a object of a captured block with a type that was never instantiated (2) + codegens call with block with call with arg that yields codegens call with block with call with arg that yields + codegens nested return codegens nested return - nexts in var assignment (#3364) nexts in var assignment (#3364) - allows using var as block arg with outer var allows using var as block arg with outer var - allows access to local variables allows access to local variables - yields inside yield (#682) yields inside yield (#682) - allows modifying yielded value (with variable) allows modifying yielded value (with variable) - returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value + codegens bug with yield not_nil! that is never not nil codegens bug with yield not_nil! that is never not nil + return from block called from dispatch return from block called from dispatch + uses splat in block argument uses splat in block argument + break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while + break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value + codegens block with union arg (2) codegens block with union arg (2) + break from block with value break from block with value + codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) codegens dispatch with block and break (2) + uses splat in block argument, many args uses splat in block argument, many args + it yields nil from another call it yields nil from another call + yields splat yields splat + returns from proc literal returns from proc literal codegens block with union with return codegens block with union with return - uses block splat argument with union types uses block splat argument with union types - return from block return from block - block with nilable type 2 block with nilable type 2 - does next from captured block does next from captured block - allows modifying yielded value (with literal) allows modifying yielded value (with literal) - doesn't codegen after while that always yields and breaks doesn't codegen after while that always yields and breaks - codegens block with return and yield and no return codegens block with return and yield and no return - union value of yielder function union value of yielder function - codegens block with nilable type with return (1) codegens block with nilable type with return (1) + codegens block call when argument type changes codegens block call when argument type changes + unpacks tuple but doesn't override local variables unpacks tuple but doesn't override local variables + codegens nested break codegens nested break + allows initialize with yield (#224) allows initialize with yield (#224) + uses block var with same name as local var uses block var with same name as local var (bug) doesn't set needs_value to true on every yield (#12442) (bug) doesn't set needs_value to true on every yield (#12442) + nexts in var assignment (#3364) nexts in var assignment (#3364) + auto-unpacks tuple auto-unpacks tuple call block from dispatch call block from dispatch + union value of yielder function union value of yielder function + uses block splat argument with union types uses block splat argument with union types + does next from captured block does next from captured block + executes yield expression if no arg is given for block executes yield expression if no arg is given for block + block with nilable type 2 block with nilable type 2 + codegens call with blocks of different type without args codegens call with blocks of different type without args + codegens block with union arg (1) codegens block with union arg (1) + allows modifying yielded value (with variable) allows modifying yielded value (with variable) + allow return from function called from yielder function allow return from function called from yielder function + pass self to yielder function pass self to yielder function return from yielder function (2) return from yielder function (2) - doesn't crash if yield exp has no type (#12670) doesn't crash if yield exp has no type (#12670) - codegens method invocation on a object of a captured block with a type that was never instantiated (2) codegens method invocation on a object of a captured block with a type that was never instantiated (2) - codegens bug with block and arg and var codegens bug with block and arg and var - codegens captured block that returns union, but proc only returns a single type codegens captured block that returns union, but proc only returns a single type - breaks in var assignment (#3364) breaks in var assignment (#3364) - return from yielder function return from yielder function - codegens block bug with conditional next and unconditional break (1) codegens block bug with conditional next and unconditional break (1) - can break without value from yielder that returns nilable (2) can break without value from yielder that returns nilable (2) - codegens method invocation on a object of a captured block with a type that was never instantiated codegens method invocation on a object of a captured block with a type that was never instantiated - codegens block with virtual type arg codegens block with virtual type arg - codegens while/break inside block codegens while/break inside block - return from block that always returns from function that always yields inside if block return from block that always returns from function that always yields inside if block - uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) - break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while break block with yielder inside while - can use self inside a block called from dispatch can use self inside a block called from dispatch - nested yields nested yields break from block returns from yielder break from block returns from yielder - allow return from function called from yielder function allow return from function called from yielder function - can use instance methods from yielder function can use instance methods from yielder function - generate inline generate inline - codegens block call when argument type changes codegens block call when argument type changes - it yields nil from another call it yields nil from another call - dispatches with captured and non-captured block (#3969) dispatches with captured and non-captured block (#3969) - assigns yield to argument assigns yield to argument - pass arguments to yielder function pass arguments to yielder function - call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars - doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s - yields splat yields splat - can set instance vars from yielder function can set instance vars from yielder function pass self and arguments to yielder function pass self and arguments to yielder function - codegens call with blocks of different type without args codegens call with blocks of different type without args - codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) - executes yield expression if no arg is given for block executes yield expression if no arg is given for block - codegens block with union arg (1) codegens block with union arg (1) - return from block that always returns from function that conditionally yields return from block that always returns from function that conditionally yields - uses splat in block argument, many args uses splat in block argument, many args - codegens block with multiple underscores (#3054) codegens block with multiple underscores (#3054) + can use self inside a block called from dispatch can use self inside a block called from dispatch + breaks from while in function called from block breaks from while in function called from block + can use instance methods from yielder function can use instance methods from yielder function + allows using var as block arg with outer var allows using var as block arg with outer var + codegens bug with block and arg and var codegens bug with block and arg and var break without value returns nil break without value returns nil - pass self to yielder function pass self to yielder function - break from block with value break from block with value - break with value from yielder that returns a nilable break with value from yielder that returns a nilable - codegens block with nilable type with return (2) codegens block with nilable type with return (2) - uses splat in block argument uses splat in block argument + doesn't crash if yield exp has no type (#12670) doesn't crash if yield exp has no type (#12670) + codegens block which always breaks but never enters (#494) codegens block which always breaks but never enters (#494) + yields more exps than block arg, through splat yields more exps than block arg, through splat + passes yield arguments passes yield arguments + codegens block with return and yield and no return codegens block with return and yield and no return + generate inline generate inline + codegens block bug with conditional next and unconditional break (4) codegens block bug with conditional next and unconditional break (4) + allows access to local variables allows access to local variables codegens block bug with conditional next and unconditional break (3) codegens block bug with conditional next and unconditional break (3) - codegens if with call with block (ssa issue) codegens if with call with block (ssa issue) - can use global constant can use global constant - codegens captured block with next inside yielded block (#2097) codegens captured block with next inside yielded block (#2097) - can access instance vars from yielder function can access instance vars from yielder function + codegens while/break inside block codegens while/break inside block + uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) uses block inside array literal (bug) + codegens block bug with conditional next and unconditional break (1) codegens block bug with conditional next and unconditional break (1) + codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) codegens dispatch with block and break (1) + breaks in var assignment (#3364) breaks in var assignment (#3364) + doesn't codegen call if arg yields and always breaks doesn't codegen call if arg yields and always breaks doesn't crash on yield exp without a type (#8100) doesn't crash on yield exp without a type (#8100) - codegens block bug with conditional next and unconditional break (4) codegens block bug with conditional next and unconditional break (4) - clears nilable var before inlining block method (#10087) clears nilable var before inlining block method (#10087) + returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value returns from block with value + can use global constant can use global constant + allows yield from dispatch call allows yield from dispatch call + return from block that always returns from function that conditionally yields return from block that always returns from function that conditionally yields + break with value from yielder that returns a nilable break with value from yielder that returns a nilable + can call methods from block when yielder is an instance method can call methods from block when yielder is an instance method + codegens block with virtual type arg codegens block with virtual type arg + codegens captured block that returns union, but proc only returns a single type codegens captured block that returns union, but proc only returns a single type block with nilable type block with nilable type - unpacks tuple but doesn't override local variables unpacks tuple but doesn't override local variables - uses block var with same name as local var uses block var with same name as local var - codegens nested break codegens nested break - passes yield arguments passes yield arguments - allows initialize with yield (#224) allows initialize with yield (#224) + doesn't codegen after while that always yields and breaks doesn't codegen after while that always yields and breaks + can access instance vars from yielder function can access instance vars from yielder function + pass arguments to yielder function pass arguments to yielder function can break without value from yielder that returns nilable (1) can break without value from yielder that returns nilable (1) + codegens block with multiple underscores (#3054) codegens block with multiple underscores (#3054) + can set instance vars from yielder function can set instance vars from yielder function + doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s doesn't crash on untyped array to_s + codegens if with call with block (ssa issue) codegens if with call with block (ssa issue) + yields inside yield (#682) yields inside yield (#682) + call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars call block from dispatch and use local vars + return from yielder function return from yielder function returns void when called with block returns void when called with block + nested yields nested yields + return from block return from block + codegens block with nilable type with return (1) codegens block with nilable type with return (1) + allows modifying yielded value (with literal) allows modifying yielded value (with literal) + return from block that always returns from function that always yields inside if block return from block that always returns from function that always yields inside if block + codegens captured block with next inside yielded block (#2097) codegens captured block with next inside yielded block (#2097) + assigns yield to argument assigns yield to argument codegens block with repeated underscore and different types (#4711) codegens block with repeated underscore and different types (#4711) - codegens block which always breaks but never enters (#494) codegens block which always breaks but never enters (#494) - - codegens call with block with call with arg that yields codegens call with block with call with arg that yields - break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value break from block with value - auto-unpacks tuple auto-unpacks tuple - returns from proc literal returns from proc literal - allows yield from dispatch call allows yield from dispatch call - doesn't codegen call if arg yields and always breaks doesn't codegen call if arg yields and always breaks - codegens block with union arg (2) codegens block with union arg (2) -Crystal::CrystalPath - finds "test_files/**" finds "test_files/**" - doesn't finds "test_files/missing_file.cr" doesn't finds "test_files/missing_file.cr" - doesn't finds "build/reproducible-path/crystal-1.14.0+dfsg/spec/compiler/crystal_path/crystal_path_spec.cr" doesn't finds "build/reproducible-path/crystal-1.14.0+dfsg/spec/compiler/crystal_path/crystal_path_spec.cr" - doesn't finds "../crystal_path/test_files/file_one" doesn't finds "../crystal_path/test_files/file_one" - includes 'lib' by default includes 'lib' by default - finds "other_test_files" finds "other_test_files" - finds "test_files/*" finds "test_files/*" - doesn't finds "../../src/file_three" doesn't finds "../../src/file_three" - finds "test_files/file_four" finds "test_files/file_four" - #each_file_expansion - ./foo ./foo - foo.cr foo.cr - foo/bar/baz foo/bar/baz - foo foo - foo.cr/bar foo.cr/bar - ./foo.cr ./foo.cr - ./foo/bar/baz ./foo/bar/baz - foo/bar foo/bar - ./foo/bar ./foo/bar - foo.cr/bar.cr foo.cr/bar.cr - finds "test_files/file_one" finds "test_files/file_one" - finds "foo.cr" finds "foo.cr" - finds "./file_two.cr" finds "./file_two.cr" - finds "./test_folder/file_three.cr" finds "./test_folder/file_three.cr" - doesn't finds "./crystal_path_spec" doesn't finds "./crystal_path_spec" - finds "test_files/file_one" finds "test_files/file_one" - finds "crystal_path_spec" finds "crystal_path_spec" - doesn't finds "test_folder/file_three.cr" doesn't finds "test_folder/file_three.cr" - finds "test_files/file_three" finds "test_files/file_three" - .expand_paths .expand_paths - doesn't finds "test_folder/*" doesn't finds "test_folder/*" - doesn't finds "file_two.cr" doesn't finds "file_two.cr" - finds "../test_folder" finds "../test_folder" - finds "test_files/file_one.cr" finds "test_files/file_one.cr" - finds "test_files/another" finds "test_files/another" - overrides path with environment variable overrides path with environment variable - finds "test_files/yet_another" finds "test_files/yet_another" - finds "test_files" finds "test_files" - finds "../**" finds "../**" - doesn't finds "./crystal_path_spec.cr" doesn't finds "./crystal_path_spec.cr" - finds "./test_folder/*" finds "./test_folder/*" -Semantic: macro overload - doesn't overwrite last macro definition if named args differs doesn't overwrite last macro definition if named args differs +Crystal::Formatter + formats "begin\n1\nrescue ex\n3\nend" formats "begin\n1\nrescue ex\n3\nend" + formats "foo do\n [foo <<-X\n bar\n X\n ]\nend" formats "foo do\n [foo <<-X\n bar\n X\n ]\nend" + formats "1.=== do\nend" formats "1.=== do\nend" + formats "macro foo\n {% if 1 %} 2 {% else %} 3 {% end %}\nend" formats "macro foo\n {% if 1 %} 2 {% else %} 3 {% end %}\nend" + formats "if 1\nelse\n2\nend\n3" formats "if 1\nelse\n2\nend\n3" + formats "case 1 \n when 2 then \n 3 \n end" formats "case 1 \n when 2 then \n 3 \n end" + formats "next *1" formats "next *1" + formats "enum Foo\nA \nend" formats "enum Foo\nA \nend" + formats "foo\n .foo1(bar\n .bar1\n .bar2)" formats "foo\n .foo1(bar\n .bar1\n .bar2)" + formats "a = begin\n1\n2\nend" formats "a = begin\n1\n2\nend" + formats "x : Int32[ 8 ]" formats "x : Int32[ 8 ]" + formats "getter foo : Int32 # comment\n\ndef foo\nend" formats "getter foo : Int32 # comment\n\ndef foo\nend" + formats ":|" formats ":|" + formats "a+1" formats "a+1" + formats "%i(one two three)" formats "%i(one two three)" + formats "begin\n #hola\n 1\nend\n" formats "begin\n #hola\n 1\nend\n" + formats "\"foo \#{ 1 + 2 }\"" formats "\"foo \#{ 1 + 2 }\"" + formats "def foo(\n a,\n b,\n)\nend" formats "def foo(\n a,\n b,\n)\nend" + formats "if 1\n [\n 1,\n ].none?\nend" formats "if 1\n [\n 1,\n ].none?\nend" + formats "enum Foo\nend" formats "enum Foo\nend" + formats "long_variable_name = [\n {\n :foo => 1,\n },\n {\n :bar => 2,\n },\n]" formats "long_variable_name = [\n {\n :foo => 1,\n },\n {\n :bar => 2,\n },\n]" + formats "1.>=(2) { 3 }" formats "1.>=(2) { 3 }" + formats "def foo(x)\n {% if true %}\n \\{% if true %}\n x = 1\n \\{% else %}\n x = 2\n \\{% end %}\n \\{% for x in y %}\n x = 1\n \\{% end %}\n \\{{x}}\n \\{% x %}\n {% end %}\nend" formats "def foo(x)\n {% if true %}\n \\{% if true %}\n x = 1\n \\{% else %}\n x = 2\n \\{% end %}\n \\{% for x in y %}\n x = 1\n \\{% end %}\n \\{{x}}\n \\{% x %}\n {% end %}\nend" + formats " <<-EOF\n 1\nEOF" formats " <<-EOF\n 1\nEOF" + formats "unless a\n # hello\n 2\nend" formats "unless a\n # hello\n 2\nend" + formats "def foo(x)\n case 1\n when self // 2\n 3\n end\nend" formats "def foo(x)\n case 1\n when self // 2\n 3\n end\nend" + formats "/foo/imx" formats "/foo/imx" + formats "if 1\n node.is_a?(T)\nend" formats "if 1\n node.is_a?(T)\nend" + formats "def foo : A(B)\n nil\nend" formats "def foo : A(B)\n nil\nend" + formats "foo : (F(A)) | D" formats "foo : (F(A)) | D" + formats "case 1\nwhen 1, # 1\n 2, # 2\n 3 # 3\n 1\nend" formats "case 1\nwhen 1, # 1\n 2, # 2\n 3 # 3\n 1\nend" + formats "class Foo; 1; end" formats "class Foo; 1; end" + formats "a = if 1\n2\nelsif 3\n4\nend" formats "a = if 1\n2\nelsif 3\n4\nend" + formats "foo(\n a: 1,\n b: 2,\n )\n" formats "foo(\n a: 1,\n b: 2,\n )\n" + formats "typeof( 1, 2, 3 )" formats "typeof( 1, 2, 3 )" + formats "instance_alignof( Int32 )" formats "instance_alignof( Int32 )" + formats "lib Foo\nfun foo() : Int32\nend" formats "lib Foo\nfun foo() : Int32\nend" + formats "def foo\n# hello\n1\nend" formats "def foo\n# hello\n1\nend" + formats "def foo(&: Int32)\nend" formats "def foo(&: Int32)\nend" + formats "asm(\"nop\" : \"a\"(0), \"b\"(1) )" formats "asm(\"nop\" : \"a\"(0), \"b\"(1) )" + formats "macro foo( x , y )\nend" formats "macro foo( x , y )\nend" + formats "def foo(@[MyAnn] &block); end" formats "def foo(@[MyAnn] &block); end" + formats "foo do\n # bar\nend" formats "foo do\n # bar\nend" + formats "foo({\n 1 => 2,\n 3 => {\n 4 => 5,\n },\n})" formats "foo({\n 1 => 2,\n 3 => {\n 4 => 5,\n },\n})" + formats "if 1\n2\nelsif\n3\n4\nelsif 5\n6\nend" formats "if 1\n2\nelsif\n3\n4\nelsif 5\n6\nend" + formats "begin\n query = <<-HEREDOC\n foo\n HEREDOC\nend" formats "begin\n query = <<-HEREDOC\n foo\n HEREDOC\nend" + formats "foo( )" formats "foo( )" + formats "%[hello]" formats "%[hello]" + formats "lib Bar\n enum Foo\n A\n end\nend" formats "lib Bar\n enum Foo\n A\n end\nend" + formats "def //(x)\n 1\nend" formats "def //(x)\n 1\nend" + formats "if 1\n# nothing\nend" formats "if 1\n# nothing\nend" + formats "\"foo \#{ 1 } \#{ __DIR__ }\"" formats "\"foo \#{ 1 } \#{ __DIR__ }\"" + formats "macro flags\n {% if 1 %}\\\n {% end %}\\\nend" formats "macro flags\n {% if 1 %}\\\n {% end %}\\\nend" + formats "a &.b.as C" formats "a &.b.as C" + formats "0x1234_u32" formats "0x1234_u32" + formats "if a\nif b\n3\nelse\n4\nend\nend" formats "if a\nif b\n3\nelse\n4\nend\nend" + formats "foo 1, do\n2\nend" formats "foo 1, do\n2\nend" + formats "break {1, 2}, {3, 4}" formats "break {1, 2}, {3, 4}" + formats "1 # foo\n2 # bar" formats "1 # foo\n2 # bar" + formats "if 1\n ->{ 1 }\nend" formats "if 1\n ->{ 1 }\nend" + formats "yield 1 , *2" formats "yield 1 , *2" + formats "$1?" formats "$1?" + formats "@[ Foo ]\ndef foo\nend" formats "@[ Foo ]\ndef foo\nend" + formats "class Foo\n@x : Int32\nend" formats "class Foo\n@x : Int32\nend" + formats "x : (A -> B)" formats "x : (A -> B)" + formats "def foo(*y, **z)\nend" formats "def foo(*y, **z)\nend" + formats "__FILE__" formats "__FILE__" + formats "foo(\n 1,\n &.foo\n)" formats "foo(\n 1,\n &.foo\n)" + formats "1 if nil?\na.b + c" formats "1 if nil?\na.b + c" + formats "enum Baz\nA = 1\nFOO\n\nEX = 3\nend" formats "enum Baz\nA = 1\nFOO\n\nEX = 3\nend" + formats "foo &.@bar" formats "foo &.@bar" + formats "::NamedTuple()" formats "::NamedTuple()" + formats "asm(\"nop\")" formats "asm(\"nop\")" + formats "foo &.bar.is_a?(Baz)" formats "foo &.bar.is_a?(Baz)" + formats "case 1\nwhen a; 2\nelse; ; b\nend" formats "case 1\nwhen a; 2\nelse; ; b\nend" + formats "/\#{1}/imx" formats "/\#{1}/imx" + formats "foo(1,\n2,\n)" formats "foo(1,\n2,\n)" + formats "def foo(x)\n {% if true %}\n x = x + 2\n {% end %}\nend" formats "def foo(x)\n {% if true %}\n x = x + 2\n {% end %}\nend" + formats "class Foo < \n Bar \n\n 1 \n\nend" formats "class Foo < \n Bar \n\n 1 \n\nend" + formats "Foo( )" formats "Foo( )" + formats "a[b] ||= c" formats "a[b] ||= c" + formats "begin\nend\n\n# a\n" formats "begin\nend\n\n# a\n" + formats "a(&.b.c.as(C))" formats "a(&.b.c.as(C))" + formats "macro [](x)\nend" formats "macro [](x)\nend" + formats "[\n a(), # b\n]" formats "[\n a(), # b\n]" + formats "asm(\"a\" :: : : \"volatile\")" formats "asm(\"a\" :: : : \"volatile\")" + formats "return *1 ,2" formats "return *1 ,2" + formats "1..\n2" formats "1..\n2" + formats "alignof( Int32 )" formats "alignof( Int32 )" + formats "ary.size = (1).to_i" formats "ary.size = (1).to_i" + formats "alias Foo = Bar" formats "alias Foo = Bar" + formats "def a\n b(\n 1, # x\n # y\n )\nend" formats "def a\n b(\n 1, # x\n # y\n )\nend" + formats "Foo( A , 1 )" formats "Foo( A , 1 )" + formats "class Foo\n def foo\n # nothing\n end\nend" formats "class Foo\n def foo\n # nothing\n end\nend" + formats "case 1 \n when 2 ; 3 \n when 4 ; 5\nend" formats "case 1 \n when 2 ; 3 \n when 4 ; 5\nend" + formats "1 // 2" formats "1 // 2" + formats "def foo(**b, # comment\n &block)\nend" formats "def foo(**b, # comment\n &block)\nend" + formats " .. 2" formats " .. 2" + formats "foo.bar\n.baz" formats "foo.bar\n.baz" + formats "module Foo; 1; end" formats "module Foo; 1; end" + formats "asm(\"nop\" : \"a\"(0) : \"b\"(1) )" formats "asm(\"nop\" : \"a\"(0) : \"b\"(1) )" + formats "1\n2 \n # foo" formats "1\n2 \n # foo" + formats "\n # hello\n\n1" formats "\n # hello\n\n1" + formats "$?" formats "$?" + formats "macro foo\n {% unless 1 %} 2 {% end %}\nend" formats "macro foo\n {% unless 1 %} 2 {% end %}\nend" + formats "\"\#{\n foo = 1}\"" formats "\"\#{\n foo = 1}\"" + formats "next" formats "next" + formats "if 1\n {% for x in y %} {% end %}\nend" formats "if 1\n {% for x in y %} {% end %}\nend" + formats "case 1\nend" formats "case 1\nend" + formats "unless a\n2\nend" formats "unless a\n2\nend" + formats "%i{one( two( three)}" formats "%i{one( two( three)}" + formats "{% if flag?(:freebsd) %}\n 1 + 2\n{% end %}\n\ncase x\nwhen 1234 then 1\nelse x\nend" formats "{% if flag?(:freebsd) %}\n 1 + 2\n{% end %}\n\ncase x\nwhen 1234 then 1\nelse x\nend" + formats "foo(\n 1, 2, &block)" formats "foo(\n 1, 2, &block)" + formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n @[MyAnn] baz\n); end" formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n @[MyAnn] baz\n); end" + formats "def foo\n 1\n #\nrescue\nend" formats "def foo\n 1\n #\nrescue\nend" + formats "asm(\n# foo\n\"nop\"\n# bar\n)" formats "asm(\n# foo\n\"nop\"\n# bar\n)" + formats "`foo \#{ bar }`" formats "`foo \#{ bar }`" + formats "{% verbatim do %}{{1}} + {{2}}{% end %}" formats "{% verbatim do %}{{1}} + {{2}}{% end %}" + formats "::Foo:: Bar" formats "::Foo:: Bar" + formats "def %(x)\n 1\nend" formats "def %(x)\n 1\nend" + formats "def a\n {\n 1, # x\n # y\n }\nend" formats "def a\n {\n 1, # x\n # y\n }\nend" + formats "def foo (\nx ,\n y ) \n end" formats "def foo (\nx ,\n y ) \n end" + formats "foo &.as?(T)" formats "foo &.as?(T)" + formats "foo({% verbatim do %}{{1}} + {{2}}{% end %})" formats "foo({% verbatim do %}{{1}} + {{2}}{% end %})" + adds trailing comma to def multi-line normal, splat, and double splat parameters + formats "macro foo(\n a,\n *b\n)\nend" formats "macro foo(\n a,\n *b\n)\nend" + formats "def foo(\n a,\n b\n)\nend" formats "def foo(\n a,\n b\n)\nend" + formats "def foo(\n a,\n *b\n)\nend" formats "def foo(\n a,\n *b\n)\nend" + formats "def foo(\n a,\n @[Ann] b\n)\nend" formats "def foo(\n a,\n @[Ann] b\n)\nend" + formats "def foo(\n a, # Foo\n b # Bar\n)\nend" formats "def foo(\n a, # Foo\n b # Bar\n)\nend" + formats "def foo(\n a,\n **b\n)\nend" formats "def foo(\n a,\n **b\n)\nend" + formats "def foo(\n a, b\n)\nend" formats "def foo(\n a, b\n)\nend" + formats "fun foo(\n a : Int32,\n ...\n)\nend" formats "fun foo(\n a : Int32,\n ...\n)\nend" + formats "def foo(\n a,\n &block\n)\nend" formats "def foo(\n a,\n &block\n)\nend" + formats "def foo(a, *args, &block)\nend" formats "def foo(a, *args, &block)\nend" + formats "def foo(\n a : Int32,\n b : Int32\n)\nend" formats "def foo(\n a : Int32,\n b : Int32\n)\nend" + formats "def foo(a, *args)\nend" formats "def foo(a, *args)\nend" + formats "def foo(\n a : Int32,\n b : Int32 = 1\n)\nend" formats "def foo(\n a : Int32,\n b : Int32 = 1\n)\nend" + formats "macro foo(\n a,\n b\n)\nend" formats "macro foo(\n a,\n b\n)\nend" + formats "def foo(a, b)\nend" formats "def foo(a, b)\nend" + formats "def foo(\n a,\n)\nend" formats "def foo(\n a,\n)\nend" + formats "def foo(\n a, b,\n c, d\n)\nend" formats "def foo(\n a, b,\n c, d\n)\nend" + formats "def foo(a, **kwargs, &block)\nend" formats "def foo(a, **kwargs, &block)\nend" + formats "def foo(a, **kwargs)\nend" formats "def foo(a, **kwargs)\nend" + formats "def foo(a)\nend" formats "def foo(a)\nend" + formats "def foo(\n a,\n @[Ann]\n b\n)\nend" formats "def foo(\n a,\n @[Ann]\n b\n)\nend" + formats "def foo(\n a,\n b c\n)\nend" formats "def foo(\n a,\n b c\n)\nend" + formats "def foo(a, &block)\nend" formats "def foo(a, &block)\nend" + formats "fun foo(\n a : Int32,\n b : Int32\n)\nend" formats "fun foo(\n a : Int32,\n b : Int32\n)\nend" + formats "\"1\#{\"\#{\"2\"}\"}3\#{\"4\"}5\"" formats "\"1\#{\"\#{\"2\"}\"}3\#{\"4\"}5\"" + formats "asm(\"nop\"\n: \"a\"(0) )" formats "asm(\"nop\"\n: \"a\"(0) )" + formats " <<-HTML\n foo\n HTML" formats " <<-HTML\n foo\n HTML" + formats " * a = 1 " formats " * a = 1 " + formats "foo &.[]?( 1, 2 )" formats "foo &.[]?( 1, 2 )" + formats "asm(\"a\" : \"b\"(c) : \"d\"(e)\n : \"f\",\n \"g\")" formats "asm(\"a\" : \"b\"(c) : \"d\"(e)\n : \"f\",\n \"g\")" + formats "case\nend" formats "case\nend" + formats "foo ((1) ? 2 : 3)" formats "foo ((1) ? 2 : 3)" + formats "if 1\n2 && 3\nend" formats "if 1\n2 && 3\nend" + formats "Foo:: Bar" formats "Foo:: Bar" + formats "abstract class Foo\nend" formats "abstract class Foo\nend" + formats "def foo\n 1 #\nrescue\nend" formats "def foo\n 1 #\nrescue\nend" + formats "{% if true %}\n <<-FOO\n hello \n FOO\n{% end %}" formats "{% if true %}\n <<-FOO\n hello \n FOO\n{% end %}" + formats "1.==(2) { 3 }" formats "1.==(2) { 3 }" + formats "foo[bar.baz]\n .qux" formats "foo[bar.baz]\n .qux" + formats "select \n when foo ; 2 \n end" formats "select \n when foo ; 2 \n end" + formats "foo \\\n 1,\n 2\n\nbar \\\n foo: 1,\n bar: 2" formats "foo \\\n 1,\n 2\n\nbar \\\n foo: 1,\n bar: 2" + formats "[\n 1, 2, # foo\n 3, 4,\n]" formats "[\n 1, 2, # foo\n 3, 4,\n]" + formats "long_variable_name = [\n {\n :foo => 1,\n }, {\n :bar => 2,\n },\n]" formats "long_variable_name = [\n {\n :foo => 1,\n }, {\n :bar => 2,\n },\n]" + formats "->Foo.foo=" formats "->Foo.foo=" + formats "a = case 1\nwhen 2\n3\nelse\n4\nend" formats "a = case 1\nwhen 2\n3\nelse\n4\nend" + formats "foo[ 1, 2 ]?" formats "foo[ 1, 2 ]?" + formats "def foo\n 1\n 2\nrescue IO\n 1\nend" formats "def foo\n 1\n 2\nrescue IO\n 1\nend" + formats "next {1, 2}, 3" formats "next {1, 2}, 3" + formats "foo bar, \\\nbaz" formats "foo bar, \\\nbaz" + formats "1\n\n\n2" formats "1\n\n\n2" + formats "foo \"bar\": 1, \"baz qux\": 2" formats "foo \"bar\": 1, \"baz qux\": 2" + formats "foo.[]" formats "foo.[]" + formats "macro foo\n %foo\nend" formats "macro foo\n %foo\nend" + formats "case 1 \n when 2 then 3 \n end" formats "case 1 \n when 2 then 3 \n end" + formats "[\n [\n 1,\n ], [\n 2,\n ], [\n 3,\n ],\n]" formats "[\n [\n 1,\n ], [\n 2,\n ], [\n 3,\n ],\n]" + formats "[\n a(),\n]" formats "[\n a(),\n]" + formats "{ {1, 2, 3} => 4 }" formats "{ {1, 2, 3} => 4 }" + formats "foo = 1\n->foo.bar(Int32)" formats "foo = 1\n->foo.bar(Int32)" + formats "enum Foo : Int32\nA = 1\ndef foo\n1\nend\nend" formats "enum Foo : Int32\nA = 1\ndef foo\n1\nend\nend" + formats "module Foo\n 1 # bar\nend\n\nmodule Foo\n 1\n # bar\nend\n\nmodule Foo\n 1\n\n # bar\nend\n\nmodule Foo\n 1\n 2\n # bar\nend\n\nmodule Foo\n 1\n 2\n\n # bar\nend\n\nif 1\n 1\n # bar\nend\n\nif 1\n 1\n\n # bar\nend\n\n1\n2\n# foo\n\n1\n2\n\n# foo\n" formats "module Foo\n 1 # bar\nend\n\nmodule Foo\n 1\n # bar\nend\n\nmodule Foo\n 1\n\n # bar\nend\n\nmodule Foo\n 1\n 2\n # bar\nend\n\nmodule Foo\n 1\n 2\n\n # bar\nend\n\nif 1\n 1\n # bar\nend\n\nif 1\n 1\n\n # bar\nend\n\n1\n2\n# foo\n\n1\n2\n\n# foo\n" + formats "{ # foo\n 1 => 2,\n}" formats "{ # foo\n 1 => 2,\n}" + formats "->foo!" formats "->foo!" + formats "(\n a = 1\n a\n)" formats "(\n a = 1\n a\n)" + formats "case\nend" formats "case\nend" + formats "begin\n / /\nend" formats "begin\n / /\nend" + formats "<<-HTML\n \#{__FILE__}\n HTML" formats "<<-HTML\n \#{__FILE__}\n HTML" + formats "foo(\n <<-HERE,\n hello\n HERE\n 1,\n)" formats "foo(\n <<-HERE,\n hello\n HERE\n 1,\n)" + formats "case 1 \n when 2 \n 3 \n else 4 \n end" formats "case 1 \n when 2 \n 3 \n else 4 \n end" + formats "x, y = <<-FOO, <<-BAR\n hello\n FOO\n world\n BAR" formats "x, y = <<-FOO, <<-BAR\n hello\n FOO\n world\n BAR" + formats "def x(@y = ->(z) {})\nend" formats "def x(@y = ->(z) {})\nend" + formats "@[Foo( 1, 2 )]" formats "@[Foo( 1, 2 )]" + formats "{\n variables => true,\n query => <<-HEREDOC,\n foo\n HEREDOC\n foo => true,\n}" formats "{\n variables => true,\n query => <<-HEREDOC,\n foo\n HEREDOC\n foo => true,\n}" + formats " {% begin %} 2 {% end %}" formats " {% begin %} 2 {% end %}" + formats "def foo\n1\nend" formats "def foo\n1\nend" + formats "->do\nx\nend" formats "->do\nx\nend" + formats "return 1 , 2" formats "return 1 , 2" + formats "def foo\n {% for x in y %}\n foo + bar\n {% end %}\nend" formats "def foo\n {% for x in y %}\n foo + bar\n {% end %}\nend" + formats "asm(\"nop\" : : )" formats "asm(\"nop\" : : )" + formats "macro foo\n {{x}} <<-FOO\n hello \n FOO\nend" formats "macro foo\n {{x}} <<-FOO\n hello \n FOO\nend" + formats "foo(\n 1,\n a: 1,\n b: 2,\n)" formats "foo(\n 1,\n a: 1,\n b: 2,\n)" + formats "{\n \"a\" => 1, \"b\" => 2,\n \"foo\" => 3, \"bar\" => 4,\n \"coconio\" => 5, \"lala\" => 6,\n}\n" formats "{\n \"a\" => 1, \"b\" => 2,\n \"foo\" => 3, \"bar\" => 4,\n \"coconio\" => 5, \"lala\" => 6,\n}\n" + formats "1 \\\nrescue 2" formats "1 \\\nrescue 2" + formats "def foo(\n\n#foo\nx,\n\n#bar\nz\n)\nend" formats "def foo(\n\n#foo\nx,\n\n#bar\nz\n)\nend" + formats "return( *1 , *2 )" formats "return( *1 , *2 )" + formats "{ * 1 * 2,\n*\n3, 4 }" formats "{ * 1 * 2,\n*\n3, 4 }" + formats "foo &.is_a?(T)" formats "foo &.is_a?(T)" + formats "x : { {A, B}, {C, D} }" formats "x : { {A, B}, {C, D} }" + formats "\"\#{\n foo = 1\n}\"" formats "\"\#{\n foo = 1\n}\"" + formats "foo { |x| (x).a }" formats "foo { |x| (x).a }" + formats "bar = foo(->{\n 1 + 2\n})" formats "bar = foo(->{\n 1 + 2\n})" + formats "def foo(x : self ?) \n end" formats "def foo(x : self ?) \n end" + formats "def foo( x , * y )\nend" formats "def foo( x , * y )\nend" + formats "macro foo\n 1 + 2 \n end" formats "macro foo\n 1 + 2 \n end" + formats "{ A: 1 }\n" formats "{ A: 1 }\n" + formats "%r(foo \#{ bar })" formats "%r(foo \#{ bar })" + formats "foo(\n 1, 2)" formats "foo(\n 1, 2)" + formats "1 ; 2" formats "1 ; 2" + formats "$? = 1" formats "$? = 1" + formats "1.<= do\nend" formats "1.<= do\nend" + formats "'a'" formats "'a'" + formats "{ \"foo\" => 1 }" formats "{ \"foo\" => 1 }" + formats "\"foo\" \\\n \"bar\" \\\n \"baz\"" formats "\"foo\" \\\n \"bar\" \\\n \"baz\"" + formats ":&+" formats ":&+" + formats "alias X = (A, B) ->\nbar : C" formats "alias X = (A, B) ->\nbar : C" + formats "macro flags\n {% if 1 %}{{1}}a{{2}}{% end %}\\\nend" formats "macro flags\n {% if 1 %}{{1}}a{{2}}{% end %}\\\nend" + formats "false" formats "false" + formats "<<-FOO\nbarfoobar\nFOO" formats "<<-FOO\nbarfoobar\nFOO" + formats "1 \\\nif 2" formats "1 \\\nif 2" + formats "@[Foo::Bar]" formats "@[Foo::Bar]" + formats "asm(\"a\" ::: \"a\"\n : \"volatile\",\n \"intel\")" formats "asm(\"a\" ::: \"a\"\n : \"volatile\",\n \"intel\")" + formats "nil" formats "nil" + formats "x : Int32*" formats "x : Int32*" + formats "if 1;\n2;\nelse;\n3;\nend" formats "if 1;\n2;\nelse;\n3;\nend" + formats "1\nyield\n2" formats "1\nyield\n2" + formats "a(&.b.c.as C)" formats "a(&.b.c.as C)" + formats "1 / 2" formats "1 / 2" + formats "+ 1" formats "+ 1" + formats "->@@foo.foo=" formats "->@@foo.foo=" + formats ":&*" formats ":&*" + formats "private def foo\nend\nprivate def bar\nend" formats "private def foo\nend\nprivate def bar\nend" + formats "foo[&.bar] = 1" formats "foo[&.bar] = 1" + formats "foo(bar(\n 1,\n baz(\n 2,\n 3,\n )\n))" formats "foo(bar(\n 1,\n baz(\n 2,\n 3,\n )\n))" + formats "-> : Int32? {}" formats "-> : Int32? {}" + formats "a[1] , b[2] = 1 , 2" formats "a[1] , b[2] = 1 , 2" + formats "foo.as?(T).bar" formats "foo.as?(T).bar" + formats "foo : (Array(String)?) | String" formats "foo : (Array(String)?) | String" + formats "def foo(@[AnnOne] @[AnnTwo] & ); end" formats "def foo(@[AnnOne] @[AnnTwo] & ); end" + formats "def foo(\n foo,\n\n @[MyAnn]\n @[MyAnn]\n & : Nil -> Nil\n); end" formats "def foo(\n foo,\n\n @[MyAnn]\n @[MyAnn]\n & : Nil -> Nil\n); end" + formats "{ foo: 1 }" formats "{ foo: 1 }" + formats "break 1, {2, 3}" formats "break 1, {2, 3}" + formats "foo(&.@bar)" formats "foo(&.@bar)" + formats "SomeLib.UppercasedFunCall 1, 2" formats "SomeLib.UppercasedFunCall 1, 2" + formats "enum Foo\n {% begin %}\n A\n B\n C\n {% end %}\nend" formats "enum Foo\n {% begin %}\n A\n B\n C\n {% end %}\nend" + formats "{ {1}.foo, 2 }" formats "{ {1}.foo, 2 }" + formats "lib Foo\n fun foo =\n\n\n bar : Void\nend" formats "lib Foo\n fun foo =\n\n\n bar : Void\nend" + formats "begin\n array[\n 0, # Zero\n ]\nend" formats "begin\n array[\n 0, # Zero\n ]\nend" + formats "next( 1 )" formats "next( 1 )" + formats "a &.b.as(C)" formats "a &.b.as(C)" + formats "@[ Foo(foo: 1) ]\ndef foo\nend" formats "@[ Foo(foo: 1) ]\ndef foo\nend" + formats "foo 1" formats "foo 1" + adds `&` to yielding methods that don't have a block parameter (#8764) + formats "def foo # bar\n yield\nend" formats "def foo # bar\n yield\nend" + formats "def foo(\nx, y)\n yield\nend" formats "def foo(\nx, y)\n yield\nend" + formats "def foo(x,\n)\n yield\nend" formats "def foo(x,\n)\n yield\nend" + formats "def foo(\nx,\n)\n yield\nend" formats "def foo(\nx,\n)\n yield\nend" + formats "def foo(x\n)\n yield\nend" formats "def foo(x\n)\n yield\nend" + formats "def foo(x,\ny,)\n yield\nend" formats "def foo(x,\ny,)\n yield\nend" + formats "def foo(x)\n yield\nend" formats "def foo(x)\n yield\nend" + formats "def foo()\n yield\nend" formats "def foo()\n yield\nend" + formats "def foo(a, **b)\n yield\nend" formats "def foo(a, **b)\n yield\nend" + formats "macro f\n yield\n {{ yield }}\nend" formats "macro f\n yield\n {{ yield }}\nend" + formats "def foo(\n)\n yield\nend" formats "def foo(\n)\n yield\nend" + formats "def foo(\nx,\ny)\n yield\nend" formats "def foo(\nx,\ny)\n yield\nend" + formats "def foo(x,\ny)\n yield\nend" formats "def foo(x,\ny)\n yield\nend" + formats "def foo(\nx)\n yield\nend" formats "def foo(\nx)\n yield\nend" + formats "def foo\n yield\nend" formats "def foo\n yield\nend" + formats "def foo(x ,)\n yield\nend" formats "def foo(x ,)\n yield\nend" + formats "1 ensure 2" formats "1 ensure 2" + formats "x : {A, B}" formats "x : {A, B}" + formats "{% if 1 %}\n 2\n{% end %}\ndef foo\nend" formats "{% if 1 %}\n 2\n{% end %}\ndef foo\nend" + formats "foo.bar(1) # comment\n .baz" formats "foo.bar(1) # comment\n .baz" + formats "foo.bar / 2\n" formats "foo.bar / 2\n" + formats "foo([\n 1,\n 2,\n 3,\n])" formats "foo([\n 1,\n 2,\n 3,\n])" + formats "macro foo()\n {% if 1 %} 2 {% end %}\nend" formats "macro foo()\n {% if 1 %} 2 {% end %}\nend" + formats "@@a" formats "@@a" + formats "if 1\n {{1 + 2}}\nend" formats "if 1\n {{1 + 2}}\nend" + formats "page= <<-HTML\n foo\nHTML" formats "page= <<-HTML\n foo\nHTML" + formats "def foo(\"bar baz\" qux)\nend" formats "def foo(\"bar baz\" qux)\nend" + formats "def foo ( x : Foo.class ) \n end" formats "def foo ( x : Foo.class ) \n end" + formats "[\n] of \n Foo " formats "[\n] of \n Foo " + formats "def foo(\n @[MyAnn] bar\n); end" formats "def foo(\n @[MyAnn] bar\n); end" + formats "def foo(a, **b : Int32)\nend" formats "def foo(a, **b : Int32)\nend" + formats "->@foo.foo" formats "->@foo.foo" + formats "foo.bar &.baz( 1 , 2 )" formats "foo.bar &.baz( 1 , 2 )" + formats "if 1;\n2;\nelsif 3;\n4;\nend" formats "if 1;\n2;\nelsif 3;\n4;\nend" + formats "foo(\n1,\n 2 \n)" formats "foo(\n1,\n 2 \n)" + formats "{ %() }" formats "{ %() }" + formats "loop do\n 1\n loop do\n 2\n rescue\n 3\n end\n 4\nend" formats "loop do\n 1\n loop do\n 2\n rescue\n 3\n end\n 4\nend" + formats "{% foo <<-X\nbar\nX\n%}" formats "{% foo <<-X\nbar\nX\n%}" + formats "\n\n1" formats "\n\n1" + formats "if a\nif b\nelse\n4\nend\nend" formats "if a\nif b\nelse\n4\nend\nend" + formats "def foo ( x : self ) \n end" formats "def foo ( x : self ) \n end" + formats "1 + 2" formats "1 + 2" + formats "def foo ( bar @@select) \n end" formats "def foo ( bar @@select) \n end" + formats "if 1\n foo(\n bar,\n # comment\n )\nend" formats "if 1\n foo(\n bar,\n # comment\n )\nend" + formats "[1, 2, 3] of Foo" formats "[1, 2, 3] of Foo" + formats "def foo(x : A(B), y)\nend" formats "def foo(x : A(B), y)\nend" + formats "10/a" formats "10/a" + formats "begin\n1\nrescue ex : Int32 \n3\nend" formats "begin\n1\nrescue ex : Int32 \n3\nend" + formats "foo &.bar" formats "foo &.bar" + formats "1 unless 2" formats "1 unless 2" + formats "-> do\nend" formats "-> do\nend" + formats "macro foo( x = 1, y = 2, &block)\nend" formats "macro foo( x = 1, y = 2, &block)\nend" + formats "class Foo\nend\nclass Bar\nend" formats "class Foo\nend\nclass Bar\nend" + formats "Hash{\n foo => <<-EOF,\n foo\n EOF\n bar => <<-BAR,\n bar\n BAR\n}" formats "Hash{\n foo => <<-EOF,\n foo\n EOF\n bar => <<-BAR,\n bar\n BAR\n}" + formats " ((1) + 2)" formats " ((1) + 2)" + formats "def `(x)\n 1\nend" formats "def `(x)\n 1\nend" + formats "a = foo(bar(baz3 do\nend))" formats "a = foo(bar(baz3 do\nend))" + formats ":\"foo\"" formats ":\"foo\"" + formats "foo do;\n1; end" formats "foo do;\n1; end" + formats "if a\n2\n3\nelse\n4\n5\nend" formats "if a\n2\n3\nelse\n4\n5\nend" + formats "[\n # foo\n] of String" formats "[\n # foo\n] of String" + formats "private getter foo" formats "private getter foo" + formats "X(typeof(begin\n e.is_a?(Y) ? 1 : 2\nend))" formats "X(typeof(begin\n e.is_a?(Y) ? 1 : 2\nend))" + formats "foo a , *b" formats "foo a , *b" + formats "def foo : (A, B) ->\n nil\nend" formats "def foo : (A, B) ->\n nil\nend" + formats "1 # foo\n/ 1 /" formats "1 # foo\n/ 1 /" + formats "def foo ( @x) \n end" formats "def foo ( @x) \n end" + formats "\"\\a\\c\#{foo}\\b\\d\"" formats "\"\\a\\c\#{foo}\\b\\d\"" + formats "return 1\n# end" formats "return 1\n# end" + formats "return( 1 , 2 )" formats "return( 1 , 2 )" + formats "break {1, 2}, 3" formats "break {1, 2}, 3" + formats "if a\n2\nelse\nend" formats "if a\n2\nelse\nend" + formats "->@foo.foo?" formats "->@foo.foo?" + formats "break { {1, 2}, {3, 4} }, 5" formats "break { {1, 2}, {3, 4} }, 5" + formats "select \n when foo \n 2 \n end" formats "select \n when foo \n 2 \n end" + formats "foo.bar(&.% baz)" formats "foo.bar(&.% baz)" + formats "<<-FOO\nfoo\n1\nFOO" formats "<<-FOO\nfoo\n1\nFOO" + formats "lib Foo\nunion Foo\nend\nend" formats "lib Foo\nunion Foo\nend\nend" + formats "select \n when foo \n 2 \n else \n 3 \n end" formats "select \n when foo \n 2 \n else \n 3 \n end" + formats "macro foo\n <<-FOO\n hello \n FOO\nend" formats "macro foo\n <<-FOO\n hello \n FOO\nend" + formats "foo do | x | \n x \n end" formats "foo do | x | \n x \n end" + formats "def foo( & block )\nend" formats "def foo( & block )\nend" + formats "def foo(\n **a\n\n # comment\n)\n 1\nend" formats "def foo(\n **a\n\n # comment\n)\n 1\nend" + formats "select # some comment\nwhen bar\n break\nend" formats "select # some comment\nwhen bar\n break\nend" + formats "foo {;;1}" formats "foo {;;1}" + formats "macro foo(x)\n {% if 1 %} 2 {% end %}\nend" formats "macro foo(x)\n {% if 1 %} 2 {% end %}\nend" + formats "begin; 1; end" formats "begin; 1; end" + formats "bar = foo(->{\n 1 + 2\n})" formats "bar = foo(->{\n 1 + 2\n})" + formats "foo &.[]?" formats "foo &.[]?" + formats "if 1\n2\nelsif\n3\n4\nend" formats "if 1\n2\nelsif\n3\n4\nend" + formats "begin\n1 ? 2 : 3\nend" formats "begin\n1 ? 2 : 3\nend" + formats "a &.!.!" formats "a &.!.!" + formats "/foo/" formats "/foo/" + formats "1/2" formats "1/2" + formats "def foo: Int32\nend" formats "def foo: Int32\nend" + formats "def foo(x @@y)\nend" formats "def foo(x @@y)\nend" + formats "1 # foo\n1234 # bar" formats "1 # foo\n1234 # bar" + formats "{ {{FOO}}, nil}" formats "{ {{FOO}}, nil}" + formats "x : Int32**" formats "x : Int32**" + formats "_ = 1" formats "_ = 1" + formats "yield( 1 , 2 )" formats "yield( 1 , 2 )" + formats "private FOO = 2\nprivate A = 1" formats "private FOO = 2\nprivate A = 1" + formats "[] of Int32\n1" formats "[] of Int32\n1" + formats "break { {1, 2}, {3, 4} }" formats "break { {1, 2}, {3, 4} }" + formats "foo([\n 1, 2,\n 3, 4,\n])" formats "foo([\n 1, 2,\n 3, 4,\n])" + formats "def foo\n2 # foo\nend" formats "def foo\n2 # foo\nend" + formats "1.[]=(2) { 3 }" formats "1.[]=(2) { 3 }" + formats "foo.[] =1" formats "foo.[] =1" + formats "@x &&= 1" formats "@x &&= 1" + formats "foo.[ 1, 2 ]?" formats "foo.[ 1, 2 ]?" + formats "macro foo\n {% if 1 %} 2 {% end %}\nend" formats "macro foo\n {% if 1 %} 2 {% end %}\nend" + formats "a = \\\n # foo\n nil" formats "a = \\\n # foo\n nil" + formats "def foo\nend\n\ndef bar\nend\n\n# foo" formats "def foo\nend\n\ndef bar\nend\n\n# foo" + formats "foo x, self // 1" formats "foo x, self // 1" + formats "def a\n b(\n 1, # x\n # y\n a: 1, # x\n # y\n b: 2 # z\n )\nend" formats "def a\n b(\n 1, # x\n # y\n a: 1, # x\n # y\n b: 2 # z\n )\nend" + formats "class Foo\n # ```\n # 1\n # ```\nend\n" formats "class Foo\n # ```\n # 1\n # ```\nend\n" + formats "foo.[]" formats "foo.[]" + formats "<<-FOO\nfoo\nFOO" formats "<<-FOO\nfoo\nFOO" + formats "0u64" formats "0u64" + formats "foo bar # comment\n\n# doc\ndef baz; end" formats "foo bar # comment\n\n# doc\ndef baz; end" + formats "a, b = \nif 1\n2\nend" formats "a, b = \nif 1\n2\nend" + formats "case 1 \n when .foo? \n 3 \n end" formats "case 1 \n when .foo? \n 3 \n end" + formats "next 1" formats "next 1" + formats "->{1}" formats "->{1}" + formats "foo 1, # comment\n do\n end" formats "foo 1, # comment\n do\n end" + formats "[\n1,\n\n2]" formats "[\n1,\n\n2]" + formats "def foo(a, # comment\n *b)\nend" formats "def foo(a, # comment\n *b)\nend" + formats "a&+1" formats "a&+1" + formats "foo(1 &+ \n2)" formats "foo(1 &+ \n2)" + formats "alias Foo=\nBar" formats "alias Foo=\nBar" + formats "1 * 2" formats "1 * 2" + formats "foo &.bar.nil?()" formats "foo &.bar.nil?()" + formats "{ {1, 2, 3} }" formats "{ {1, 2, 3} }" + formats "def foo(x, *, z)\nend" formats "def foo(x, *, z)\nend" + formats "foo {;1}" formats "foo {;1}" + formats "(size - 1).downto(0) do |i|\n yield @buffer[i]\nend" formats "(size - 1).downto(0) do |i|\n yield @buffer[i]\nend" + formats "1 #foo \n2 #bar" formats "1 #foo \n2 #bar" + formats "1*2" formats "1*2" + formats "{ {% for x in 1..2 %}3{% end %}, nil }" formats "{ {% for x in 1..2 %}3{% end %}, nil }" + formats "@x[ 1 ] += 2" formats "@x[ 1 ] += 2" + formats "macro foo\n {{\n1 + 2 }}\nend" formats "macro foo\n {{\n1 + 2 }}\nend" + formats "yield 1\n2" formats "yield 1\n2" + formats "case 1\nwhen a; 2\nelse; b\nend" formats "case 1\nwhen a; 2\nelse; b\nend" + formats "foo(bar(\n 1,\n baz(2,\n 3,\n )\n))" formats "foo(bar(\n 1,\n baz(2,\n 3,\n )\n))" + formats "def foo ( x , y ,\n) \n end" formats "def foo ( x , y ,\n) \n end" + formats "lib Foo::Bar\nend" formats "lib Foo::Bar\nend" + formats "module Ton\n macro foo\n class {{name.id}}\n end\n end\nend" formats "module Ton\n macro foo\n class {{name.id}}\n end\n end\nend" + formats "A = 10\nFOO = 123\nBARBAZ = 1234\n" formats "A = 10\nFOO = 123\nBARBAZ = 1234\n" + formats "next 1 , *2" formats "next 1 , *2" + formats " <<-HTML\n hello \n world \n HTML" formats " <<-HTML\n hello \n world \n HTML" + formats "def foo\n # Comment\n\n\nend" formats "def foo\n # Comment\n\n\nend" + formats "foo &.[](1, 2)" formats "foo &.[](1, 2)" + formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n\n @[MyAnn] baz\n); end" formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n\n @[MyAnn] baz\n); end" + formats "macro foo\n %foo{x.id+2}\nend" formats "macro foo\n %foo{x.id+2}\nend" + formats "lib LibFoo\n {% begin %}\n fun foo : Int32\n {% end %}\nend" formats "lib LibFoo\n {% begin %}\n fun foo : Int32\n {% end %}\nend" + formats "bar do\n foo <<-X\n bar\n X\nend" formats "bar do\n foo <<-X\n bar\n X\nend" + formats "yield( 1 )" formats "yield( 1 )" + formats "lib Foo\n {% if 1 %}\n fun foo\n {% end %}\nend\n\nmacro bar\n 1\nend" formats "lib Foo\n {% if 1 %}\n fun foo\n {% end %}\nend\n\nmacro bar\n 1\nend" + formats "foo 1, # comment\n # bar\n do\n end" formats "foo 1, # comment\n # bar\n do\n end" + formats "1 ? 2 : 3" formats "1 ? 2 : 3" + formats "class Foo;end" formats "class Foo;end" + formats "->Foo.foo!" formats "->Foo.foo!" + formats "if a\n2\n3\nend" formats "if a\n2\n3\nend" + formats "x, y, z = <<-FOO, <<-BAR, <<-BAZ\n hello\n FOO\n world\n BAR\n qux\nBAZ" formats "x, y, z = <<-FOO, <<-BAR, <<-BAZ\n hello\n FOO\n world\n BAR\n qux\nBAZ" + Unicode bi-directional control characters + formats "NamedTuple(\"\u202B\": Int32)" formats "NamedTuple(\"\u202B\": Int32)" + formats "NamedTuple(\"\u2068\": Int32)" formats "NamedTuple(\"\u2068\": Int32)" + formats "{\"\u202C\": 1}" formats "{\"\u202C\": 1}" + formats "%q(\u2069)" formats "%q(\u2069)" + formats "%(\u202B)" formats "%(\u202B)" + formats "/\u202A/" formats "/\u202A/" + formats "<<-'EOS'\n\u2066\nEOS" formats "<<-'EOS'\n\u2066\nEOS" + formats "%(\u202C)" formats "%(\u202C)" + formats "<<-'EOS'\n\u202C\nEOS" formats "<<-'EOS'\n\u202C\nEOS" + formats "%Q(\u202B)" formats "%Q(\u202B)" + formats "{\"\u2067\": 1}" formats "{\"\u2067\": 1}" + formats "/\u202E\#{1}/" formats "/\u202E\#{1}/" + formats "/\u2068\#{1}/" formats "/\u2068\#{1}/" + formats "%r(\u202D\#{1})" formats "%r(\u202D\#{1})" + formats "foo(\"\u2069\": 1)" formats "foo(\"\u2069\": 1)" + formats "foo(\"\u2067\": 1)" formats "foo(\"\u2067\": 1)" + formats "\"\\c\u202C\"" formats "\"\\c\u202C\"" + formats "<<-EOS\n\u2067\nEOS" formats "<<-EOS\n\u2067\nEOS" + formats "%r(\u202B\#{1})" formats "%r(\u202B\#{1})" + formats "<<-EOS\n\u2066\nEOS" formats "<<-EOS\n\u2066\nEOS" + formats "foo(\"\u2068\": 1)" formats "foo(\"\u2068\": 1)" + formats "/\u202B/" formats "/\u202B/" + formats "/\u202D/" formats "/\u202D/" + formats "def foo(\"\u2067\" x)\nend" formats "def foo(\"\u2067\" x)\nend" + formats "<<-'EOS'\n\u202A\nEOS" formats "<<-'EOS'\n\u202A\nEOS" + formats "%w(\u202C)" formats "%w(\u202C)" + formats "NamedTuple(\"\u202A\": Int32)" formats "NamedTuple(\"\u202A\": Int32)" + formats "%w(\u202A)" formats "%w(\u202A)" + formats "\"\u202D\#{1}\"" formats "\"\u202D\#{1}\"" + formats "<<-EOS\n\u2066\#{1}\nEOS" formats "<<-EOS\n\u2066\#{1}\nEOS" + formats "/\u202E/" formats "/\u202E/" + formats "%i(\u202E)" formats "%i(\u202E)" + formats "%(\u202D)" formats "%(\u202D)" + formats "def foo(\"\u202A\" x)\nend" formats "def foo(\"\u202A\" x)\nend" + formats "%Q(\u2069)" formats "%Q(\u2069)" + formats "<<-EOS\n\u2069\nEOS" formats "<<-EOS\n\u2069\nEOS" + formats "%r(\u2067)" formats "%r(\u2067)" + formats "foo(\"\u202A\": 1)" formats "foo(\"\u202A\": 1)" + formats "%r(\u2069)" formats "%r(\u2069)" + formats "def foo(\"\u2069\" x)\nend" formats "def foo(\"\u2069\" x)\nend" + formats "%r(\u202D)" formats "%r(\u202D)" + formats "%q(\u202D)" formats "%q(\u202D)" + formats "\"\u202C\"" formats "\"\u202C\"" + formats "\"\\c\u2069\"" formats "\"\\c\u2069\"" + formats "\"\u202D\"" formats "\"\u202D\"" + formats "%(\u2067)" formats "%(\u2067)" + formats "%r(\u202B)" formats "%r(\u202B)" + formats "<<-'EOS'\n\u202B\nEOS" formats "<<-'EOS'\n\u202B\nEOS" + formats "def foo(\"\u2066\" x)\nend" formats "def foo(\"\u2066\" x)\nend" + formats "\"\u202E\#{1}\"" formats "\"\u202E\#{1}\"" + formats "%Q(\u2067)" formats "%Q(\u2067)" + formats "def foo(\"\u202D\" x)\nend" formats "def foo(\"\u202D\" x)\nend" + formats "%(\u202A)" formats "%(\u202A)" + formats "<<-EOS\n\u202D\nEOS" formats "<<-EOS\n\u202D\nEOS" + formats "{\"\u202A\": 1}" formats "{\"\u202A\": 1}" + formats "\"\\c\u202A\"" formats "\"\\c\u202A\"" + formats "NamedTuple(\"\u202E\": Int32)" formats "NamedTuple(\"\u202E\": Int32)" + formats "/\u202C/" formats "/\u202C/" + formats "%Q(\u2068)" formats "%Q(\u2068)" + formats "%i(\u2068)" formats "%i(\u2068)" + formats "%w(\u202D)" formats "%w(\u202D)" + formats "def foo(\"\u202C\" x)\nend" formats "def foo(\"\u202C\" x)\nend" + formats "\"\\c\u2068\"" formats "\"\\c\u2068\"" + formats "%q(\u2067)" formats "%q(\u2067)" + formats "foo(\"\u202D\": 1)" formats "foo(\"\u202D\": 1)" + formats "%Q(\u202C)" formats "%Q(\u202C)" + formats "\"\\c\u202E\#{1}\"" formats "\"\\c\u202E\#{1}\"" + formats "%Q(\u202C\#{1})" formats "%Q(\u202C\#{1})" + formats "def foo(\"\u2068\" x)\nend" formats "def foo(\"\u2068\" x)\nend" + formats "<<-EOS\n\u2069\#{1}\nEOS" formats "<<-EOS\n\u2069\#{1}\nEOS" + formats "{\"\u202D\": 1}" formats "{\"\u202D\": 1}" + formats "<<-EOS\n\u202C\nEOS" formats "<<-EOS\n\u202C\nEOS" + formats "/\u202D\#{1}/" formats "/\u202D\#{1}/" + formats "NamedTuple(\"\u2066\": Int32)" formats "NamedTuple(\"\u2066\": Int32)" + formats "%q(\u2066)" formats "%q(\u2066)" + formats "<<-EOS\n\u202C\#{1}\nEOS" formats "<<-EOS\n\u202C\#{1}\nEOS" + formats "%w(\u202E)" formats "%w(\u202E)" + formats "%i(\u202A)" formats "%i(\u202A)" + formats "{\"\u2068\": 1}" formats "{\"\u2068\": 1}" + formats "NamedTuple(\"\u202C\": Int32)" formats "NamedTuple(\"\u202C\": Int32)" + formats "\"\\c\u202D\#{1}\"" formats "\"\\c\u202D\#{1}\"" + formats "%i(\u2066)" formats "%i(\u2066)" + formats "<<-'EOS'\n\u2067\nEOS" formats "<<-'EOS'\n\u2067\nEOS" + formats "{\"\u202B\": 1}" formats "{\"\u202B\": 1}" + formats "%r(\u202E)" formats "%r(\u202E)" + formats "\"\u2069\#{1}\"" formats "\"\u2069\#{1}\"" + formats "%r(\u2069\#{1})" formats "%r(\u2069\#{1})" + formats "%q(\u2068)" formats "%q(\u2068)" + formats "foo(\"\u202C\": 1)" formats "foo(\"\u202C\": 1)" + formats "%r(\u2067\#{1})" formats "%r(\u2067\#{1})" + formats "%r(\u202C)" formats "%r(\u202C)" + formats "{\"\u2069\": 1}" formats "{\"\u2069\": 1}" + formats "\"\u2069\"" formats "\"\u2069\"" + formats "%q(\u202E)" formats "%q(\u202E)" + formats "%r(\u202C\#{1})" formats "%r(\u202C\#{1})" + formats "/\u202B\#{1}/" formats "/\u202B\#{1}/" + formats "NamedTuple(\"\u2069\": Int32)" formats "NamedTuple(\"\u2069\": Int32)" + formats "/\u2068/" formats "/\u2068/" + formats "%i(\u202D)" formats "%i(\u202D)" + formats "%i(\u202C)" formats "%i(\u202C)" + formats "%r(\u2068\#{1})" formats "%r(\u2068\#{1})" + formats "foo(\"\u202B\": 1)" formats "foo(\"\u202B\": 1)" + formats "\"\\c\u2068\#{1}\"" formats "\"\\c\u2068\#{1}\"" + formats "<<-EOS\n\u2068\#{1}\nEOS" formats "<<-EOS\n\u2068\#{1}\nEOS" + formats "%q(\u202C)" formats "%q(\u202C)" + formats "<<-EOS\n\u202A\#{1}\nEOS" formats "<<-EOS\n\u202A\#{1}\nEOS" + formats "%(\u202E)" formats "%(\u202E)" + formats "<<-EOS\n\u202D\#{1}\nEOS" formats "<<-EOS\n\u202D\#{1}\nEOS" + formats "{\"\u202E\": 1}" formats "{\"\u202E\": 1}" + formats "\"\u202A\#{1}\"" formats "\"\u202A\#{1}\"" + formats "%(\u2069)" formats "%(\u2069)" + formats "%w(\u202B)" formats "%w(\u202B)" + formats "<<-'EOS'\n\u202E\nEOS" formats "<<-'EOS'\n\u202E\nEOS" + formats "<<-'EOS'\n\u202D\nEOS" formats "<<-'EOS'\n\u202D\nEOS" + formats "<<-EOS\n\u202E\#{1}\nEOS" formats "<<-EOS\n\u202E\#{1}\nEOS" + formats "%r(\u2066)" formats "%r(\u2066)" + formats "%Q(\u2066)" formats "%Q(\u2066)" + formats "\"\u202B\"" formats "\"\u202B\"" + formats "<<-EOS\n\u202E\nEOS" formats "<<-EOS\n\u202E\nEOS" + formats "%Q(\u202A\#{1})" formats "%Q(\u202A\#{1})" + formats "def foo(\"\u202B\" x)\nend" formats "def foo(\"\u202B\" x)\nend" + formats "\"\\c\u2067\#{1}\"" formats "\"\\c\u2067\#{1}\"" + formats "\"\u2068\"" formats "\"\u2068\"" + formats "\"\u2067\"" formats "\"\u2067\"" + formats "%Q(\u202E\#{1})" formats "%Q(\u202E\#{1})" + formats "/\u2069/" formats "/\u2069/" + formats "%Q(\u2067\#{1})" formats "%Q(\u2067\#{1})" + formats "%Q(\u2069\#{1})" formats "%Q(\u2069\#{1})" + formats "\"\u202B\#{1}\"" formats "\"\u202B\#{1}\"" + formats "%w(\u2066)" formats "%w(\u2066)" + formats "\"\u2066\#{1}\"" formats "\"\u2066\#{1}\"" + formats "%Q(\u202D\#{1})" formats "%Q(\u202D\#{1})" + formats "\"\\c\u202A\#{1}\"" formats "\"\\c\u202A\#{1}\"" + formats "\"\u202C\#{1}\"" formats "\"\u202C\#{1}\"" + formats "/\u2066\#{1}/" formats "/\u2066\#{1}/" + formats "\"\\c\u2069\#{1}\"" formats "\"\\c\u2069\#{1}\"" + formats "NamedTuple(\"\u2067\": Int32)" formats "NamedTuple(\"\u2067\": Int32)" + formats "<<-EOS\n\u202A\nEOS" formats "<<-EOS\n\u202A\nEOS" + formats "/\u202C\#{1}/" formats "/\u202C\#{1}/" + formats "NamedTuple(\"\u202D\": Int32)" formats "NamedTuple(\"\u202D\": Int32)" + formats "%r(\u2066\#{1})" formats "%r(\u2066\#{1})" + formats "/\u2069\#{1}/" formats "/\u2069\#{1}/" + formats "{\"\u2066\": 1}" formats "{\"\u2066\": 1}" + formats "%i(\u2067)" formats "%i(\u2067)" + formats "%(\u2066)" formats "%(\u2066)" + formats "%w(\u2068)" formats "%w(\u2068)" + formats "\"\\c\u202B\#{1}\"" formats "\"\\c\u202B\#{1}\"" + formats "\"\\c\u202E\"" formats "\"\\c\u202E\"" + formats "\"\u2068\#{1}\"" formats "\"\u2068\#{1}\"" + formats "\"\u202A\"" formats "\"\u202A\"" + formats "<<-'EOS'\n\u2068\nEOS" formats "<<-'EOS'\n\u2068\nEOS" + formats "%r(\u202A)" formats "%r(\u202A)" + formats "\"\\c\u202B\"" formats "\"\\c\u202B\"" + formats "\"\u202E\"" formats "\"\u202E\"" + formats "%q(\u202B)" formats "%q(\u202B)" + formats "/\u2067/" formats "/\u2067/" + formats "%(\u2068)" formats "%(\u2068)" + formats "<<-'EOS'\n\u2069\nEOS" formats "<<-'EOS'\n\u2069\nEOS" + formats "%r(\u202A\#{1})" formats "%r(\u202A\#{1})" + formats "<<-EOS\n\u2068\nEOS" formats "<<-EOS\n\u2068\nEOS" + formats "%r(\u202E\#{1})" formats "%r(\u202E\#{1})" + formats "%Q(\u202B\#{1})" formats "%Q(\u202B\#{1})" + formats "\"\\c\u202D\"" formats "\"\\c\u202D\"" + formats "%Q(\u202E)" formats "%Q(\u202E)" + formats "%i(\u202B)" formats "%i(\u202B)" + formats "\"\\c\u2066\"" formats "\"\\c\u2066\"" + formats "<<-EOS\n\u2067\#{1}\nEOS" formats "<<-EOS\n\u2067\#{1}\nEOS" + formats "\"\\c\u2066\#{1}\"" formats "\"\\c\u2066\#{1}\"" + formats "foo(\"\u202E\": 1)" formats "foo(\"\u202E\": 1)" + formats "\"\\c\u202C\#{1}\"" formats "\"\\c\u202C\#{1}\"" + formats "<<-EOS\n\u202B\nEOS" formats "<<-EOS\n\u202B\nEOS" + formats "<<-EOS\n\u202B\#{1}\nEOS" formats "<<-EOS\n\u202B\#{1}\nEOS" + formats "%Q(\u2066\#{1})" formats "%Q(\u2066\#{1})" + formats "%w(\u2067)" formats "%w(\u2067)" + formats "%Q(\u2068\#{1})" formats "%Q(\u2068\#{1})" + formats "/\u2067\#{1}/" formats "/\u2067\#{1}/" + formats "\"\u2066\"" formats "\"\u2066\"" + formats "%Q(\u202A)" formats "%Q(\u202A)" + formats "/\u202A\#{1}/" formats "/\u202A\#{1}/" + formats "%r(\u2068)" formats "%r(\u2068)" + formats "%w(\u2069)" formats "%w(\u2069)" + formats "%Q(\u202D)" formats "%Q(\u202D)" + formats "%i(\u2069)" formats "%i(\u2069)" + formats "%q(\u202A)" formats "%q(\u202A)" + formats "\"\u2067\#{1}\"" formats "\"\u2067\#{1}\"" + formats "def foo(\"\u202E\" x)\nend" formats "def foo(\"\u202E\" x)\nend" + formats "\"\\c\u2067\"" formats "\"\\c\u2067\"" + formats "foo(\"\u2066\": 1)" formats "foo(\"\u2066\": 1)" + formats "/\u2066/" formats "/\u2066/" + formats "yield( *1 , *2 )" formats "yield( *1 , *2 )" + formats "foo(//, //)" formats "foo(//, //)" + formats "&- 1" formats "&- 1" + formats "if a\n b &c\nend" formats "if a\n b &c\nend" + formats "foo = 1\n->foo.foo?" formats "foo = 1\n->foo.foo?" + formats "foo(->do\n 1 + 2\nend)" formats "foo(->do\n 1 + 2\nend)" + formats "# ```text\n# 1 + 2\n# ```\n#\n# ```\n# 3 + 4\n# ```" formats "# ```text\n# 1 + 2\n# ```\n#\n# ```\n# 3 + 4\n# ```" + formats "def a\n b(\n a: 1, # x\n # y\n b: 2\n )\nend" formats "def a\n b(\n a: 1, # x\n # y\n b: 2\n )\nend" + formats "x : (A -> B)?" formats "x : (A -> B)?" + formats "with foo yield bar" formats "with foo yield bar" + formats "1 &+ 2" formats "1 &+ 2" + formats "sizeof( Int32 )" formats "sizeof( Int32 )" + formats "foo.bar(&.%(baz))" formats "foo.bar(&.%(baz))" + formats "lib Foo\nfun foo( ... ) : Int32\nend" formats "lib Foo\nfun foo( ... ) : Int32\nend" + formats "foo : A(B)\nbar : C" formats "foo : A(B)\nbar : C" + formats "foo &.bar.responds_to?(:baz)" formats "foo &.bar.responds_to?(:baz)" + formats "module Moo \n\n 1 \n\nend" formats "module Moo \n\n 1 \n\nend" + formats "NamedTuple(\n a: Int32,)" formats "NamedTuple(\n a: Int32,)" + formats "{ 1 => 2 }" formats "{ 1 => 2 }" + formats "x : {A, B, }" formats "x : {A, B, }" + formats "foo[&.bar]?" formats "foo[&.bar]?" + formats "struct Foo \n\n 1 \n\nend" formats "struct Foo \n\n 1 \n\nend" + formats "def foo # bar\n # baz\nend" formats "def foo # bar\n # baz\nend" + formats "if 1\n ((1) + 2)\nend" formats "if 1\n ((1) + 2)\nend" + formats "->do\nend" formats "->do\nend" + formats "foo[x: 1, &.bar] = 1" formats "foo[x: 1, &.bar] = 1" + formats "asm(\"nop\" : \"a\"(0), \"b\"(1)\n: \"c\"(2), \"d\"(3) )" formats "asm(\"nop\" : \"a\"(0), \"b\"(1)\n: \"c\"(2), \"d\"(3) )" + formats "-> : Int32* {}" formats "-> : Int32* {}" + gives proper line number in syntax error inside macro gives proper line number in syntax error inside macro + formats "%" formats "%" + formats "def foo ( x : Int32 ) \n end" formats "def foo ( x : Int32 ) \n end" + formats "case 1 \n when 2 ; 3 \n end" formats "case 1 \n when 2 ; 3 \n end" + formats "#!shebang\n1 + 2" formats "#!shebang\n1 + 2" + formats "def foo=(x)\nend" formats "def foo=(x)\nend" + formats "unless a\nelse\n2\nend" formats "unless a\nelse\n2\nend" + formats "return {1, 2}, 3" formats "return {1, 2}, 3" + formats "x[ y ] += 1" formats "x[ y ] += 1" + formats "foo({\n 1 => 2,\n 3 => 4,\n 5 => 6,\n})" formats "foo({\n 1 => 2,\n 3 => 4,\n 5 => 6,\n})" + formats "macro foo\n {{ 1 + 2 }}\\\n 1\n end" formats "macro foo\n {{ 1 + 2 }}\\\n 1\n end" + formats "->(){}" formats "->(){}" + formats ":foo" formats ":foo" + formats "-> : {Int32} { String }" formats "-> : {Int32} { String }" + formats "break 1 , *2" formats "break 1 , *2" + formats " <<-HTML\n foo\nHTML" formats " <<-HTML\n foo\nHTML" + formats "lib Foo\nstruct Foo\nx : Int32\nend\nend" formats "lib Foo\nstruct Foo\nx : Int32\nend\nend" + formats "def bar\n foo(<<-X,\n a\n X\n 1)\nend" formats "def bar\n foo(<<-X,\n a\n X\n 1)\nend" + formats "foo(&.bar)" formats "foo(&.bar)" + formats "macro foo\n 1 \n {{ \n 42 \n }} \n 2 \nend" formats "macro foo\n 1 \n {{ \n 42 \n }} \n 2 \nend" + formats "lib Foo\nalias Foo = Bar -> \n$a : Int32\nend" formats "lib Foo\nalias Foo = Bar -> \n$a : Int32\nend" + formats "def foo ( x ) : Int32 \n end" formats "def foo ( x ) : Int32 \n end" + formats "class Foo\n enum Bar\n A; B; C;\n D; E; F\nend\nend\n" formats "class Foo\n enum Bar\n A; B; C;\n D; E; F\nend\nend\n" + formats "a &.!" formats "a &.!" + formats "a = %w(\n one two\n three four\n)" formats "a = %w(\n one two\n three four\n)" + formats "responds_to? :foo" formats "responds_to? :foo" + formats "1.!=() { 3 }" formats "1.!=() { 3 }" + formats "case 1 # foo\nwhen 2\nend" formats "case 1 # foo\nwhen 2\nend" + formats "if a\n2\nend" formats "if a\n2\nend" + formats "select\nwhen foo\n # foo\n # bar\nelse\n # foo\n # bar\nend" formats "select\nwhen foo\n # foo\n # bar\nelse\n # foo\n # bar\nend" + formats "if 1\nbegin\n2\nensure\n3\nend\nend" formats "if 1\nbegin\n2\nensure\n3\nend\nend" + formats "[\n # foo\n 1,\n\n # bar\n 2,\n]" formats "[\n # foo\n 1,\n\n # bar\n 2,\n]" + formats "{%\n if 1\n 2\n end\n%}" formats "{%\n if 1\n 2\n end\n%}" + formats "{\n \"foo\": 1,\n \"babraz\": 2,\n}" formats "{\n \"foo\": 1,\n \"babraz\": 2,\n}" + formats "if 1 # foo\n2\nend" formats "if 1 # foo\n2\nend" + formats "foo &.==(2)" formats "foo &.==(2)" + formats "def foo(x)\n case //\n when //\n 3\n end\nend" formats "def foo(x)\n case //\n when //\n 3\n end\nend" + formats "begin\n a\nend.b { }\nc" formats "begin\n a\nend.b { }\nc" + formats "x = uninitialized Int32" formats "x = uninitialized Int32" + formats "foo ()" formats "foo ()" + formats "[/ /, / /]" formats "[/ /, / /]" + formats "def foo( & )\nend" formats "def foo( & )\nend" + formats "::Tuple(T)" formats "::Tuple(T)" + formats "1\n.as(Int32)" formats "1\n.as(Int32)" + formats "if # some comment\n 2 # another\n 3 # final \n end # end " formats "if # some comment\n 2 # another\n 3 # final \n end # end " + formats "if 0\n1 &&\n2 &&\n3\nend" formats "if 0\n1 &&\n2 &&\n3\nend" + formats "macro foo\n {% for value, i in values %}\\\n {% if true %}\\\n {% end %}\\\n {{ 1 }}/\n {% end %}\\\nend\n\n{\n 1 => 2,\n 1234 => 5,\n}\n" formats "macro foo\n {% for value, i in values %}\\\n {% if true %}\\\n {% end %}\\\n {{ 1 }}/\n {% end %}\\\nend\n\n{\n 1 => 2,\n 1234 => 5,\n}\n" + formats "\"\\\\\\\"\\#\\a\\b\\n\\r\\t\#{foo}\\v\\f\\e\"" formats "\"\\\\\\\"\\#\\a\\b\\n\\r\\t\#{foo}\\v\\f\\e\"" + formats "1 if 2" formats "1 if 2" + formats "foo(\n1,\n\n 2 \n)" formats "foo(\n1,\n\n 2 \n)" + formats "return { 1 , 2 }" formats "return { 1 , 2 }" + formats "1 &&\n2" formats "1 &&\n2" + formats "foo[1, &.bar] = 1" formats "foo[1, &.bar] = 1" + formats "def foo(\n foo,\n\n @[MyAnn]\n &block\n); end" formats "def foo(\n foo,\n\n @[MyAnn]\n &block\n); end" + formats "def foo(\n a,\n &block\n)\nend" formats "def foo(\n a,\n &block\n)\nend" + formats "{\n <<-KEY => 1,\n key\n KEY\n}" formats "{\n <<-KEY => 1,\n key\n KEY\n}" + formats "yield 1 , \n2" formats "yield 1 , \n2" + formats "break( 1 , 2 )" formats "break( 1 , 2 )" + formats "1.<=() { 3 }" formats "1.<=() { 3 }" + formats "a = foo &.bar do\n 1 + 2\nend" formats "a = foo &.bar do\n 1 + 2\nend" + formats "foo &.[]=( 1, 2 )" formats "foo &.[]=( 1, 2 )" + formats "next {1, 2}, {3, 4}" formats "next {1, 2}, {3, 4}" + formats "yield *1 ,2" formats "yield *1 ,2" + formats "asm(\"nop\" :::: \"volatile\" , \"alignstack\" , \"intel\" )" formats "asm(\"nop\" :::: \"volatile\" , \"alignstack\" , \"intel\" )" + formats "foo(self // 1)" formats "foo(self // 1)" + formats "foo : self? | A" formats "foo : self? | A" + formats "class Foo\n# nothing\nend" formats "class Foo\n# nothing\nend" + formats ":<<" formats ":<<" + formats "->: Int32 do\nx\nend" formats "->: Int32 do\nx\nend" + formats "foo[x: 1, &.bar]" formats "foo[x: 1, &.bar]" + formats "def foo(x, **z, &block)\nend" formats "def foo(x, **z, &block)\nend" + formats "- 1" formats "- 1" + formats "あ.い, う.え.お = 1, 2" formats "あ.い, う.え.お = 1, 2" + formats "# Hello\n#\n# ```\n# puts 1+2 # bye\n# 1+2 # hello\n#\n# 1+2\n# ```\n\n# ```\n# puts 1+2\n\n# ```\n# puts 1+2\n\n# Hola\n#\n# 1+2\n# foo do\n# 3+4\n# end\n\n# Hey\n#\n# 1+2\n# foo do\n# 3+4\n# end\n#\n# ```\n# 1+2\n# ```\n#\n# 1+2\n#\n# Bye\n" formats "# Hello\n#\n# ```\n# puts 1+2 # bye\n# 1+2 # hello\n#\n# 1+2\n# ```\n\n# ```\n# puts 1+2\n\n# ```\n# puts 1+2\n\n# Hola\n#\n# 1+2\n# foo do\n# 3+4\n# end\n\n# Hey\n#\n# 1+2\n# foo do\n# 3+4\n# end\n#\n# ```\n# 1+2\n# ```\n#\n# 1+2\n#\n# Bye\n" + formats "->foo?" formats "->foo?" + formats "asm(\"a\" : : :: \"volatile\")" formats "asm(\"a\" : : :: \"volatile\")" + formats "a = if 1\n2\nelse\n3\nend" formats "a = if 1\n2\nelse\n3\nend" + formats "foo(\n# x\n1,\n\n# y\nz: 2\n)" formats "foo(\n# x\n1,\n\n# y\nz: 2\n)" + formats "<<-HTML\n hello \n world \n HTML" formats "<<-HTML\n hello \n world \n HTML" + formats "class Foo \n\n 1 \n\nend" formats "class Foo \n\n 1 \n\nend" + formats "foo : (A) | D" formats "foo : (A) | D" + formats "return { {1, 2}, {3, 4} }, 5" formats "return { {1, 2}, {3, 4} }, 5" + formats "\"\#{\"\#{foo}\"}\"" formats "\"\#{\"\#{foo}\"}\"" + formats "pointerof( @a )" formats "pointerof( @a )" + formats "{% if true %}\n # x\n{% end %}" formats "{% if true %}\n # x\n{% end %}" + formats "yield(1 , \n2)" formats "yield(1 , \n2)" + formats "def foo( @[MyAnn] v ); end" formats "def foo( @[MyAnn] v ); end" + formats "1 || 2" formats "1 || 2" + formats "def foo\na = bar do\n1\nend\nend" formats "def foo\na = bar do\n1\nend\nend" + formats "asm(\"nop\" : \"a\"(0)\n: \"b\"(1), \"c\"(2) )" formats "asm(\"nop\" : \"a\"(0)\n: \"b\"(1), \"c\"(2) )" + formats "{1 => 2,\n 3 => 4, # lala\n}\n" formats "{1 => 2,\n 3 => 4, # lala\n}\n" + formats "Hash{\n foo => <<-EOF\n foo\n EOF\n}" formats "Hash{\n foo => <<-EOF\n foo\n EOF\n}" + formats "foo = 1\n->foo.[]=(Int32)" formats "foo = 1\n->foo.[]=(Int32)" + formats "if 1\n[ 1 , 2 , 3 ]\nend" formats "if 1\n[ 1 , 2 , 3 ]\nend" + formats "foo[&.bar]" formats "foo[&.bar]" + formats " {{\n1 + 2 }}" formats " {{\n1 + 2 }}" + formats "Foo( * T, { * A ,*\n B } )" formats "Foo( * T, { * A ,*\n B } )" + formats "yield *1" formats "yield *1" + formats "<<-HTML\n \#{\"foo\"}\n \#{\"bar\"}\n HTML" formats "<<-HTML\n \#{\"foo\"}\n \#{\"bar\"}\n HTML" + formats "foo(1, ) { }" formats "foo(1, ) { }" + formats "1.!=(2) { 3 }" formats "1.!=(2) { 3 }" + formats "instance_sizeof( Int32 )" formats "instance_sizeof( Int32 )" + formats "foo . bar" formats "foo . bar" + formats "@x : A(B | C)?" formats "@x : A(B | C)?" + formats "class Actor\n macro inherited\nend\nend\n" formats "class Actor\n macro inherited\nend\nend\n" + formats "foo ( )" formats "foo ( )" + formats "asm(\"a\" :: \"d\"(e)\n)" formats "asm(\"a\" :: \"d\"(e)\n)" + formats "def foo : A | B(C)\n nil\nend" formats "def foo : A | B(C)\n nil\nend" + formats "bar = foo({\n 1 => 2,\n 3 => 4,\n 5 => 6,\n })" formats "bar = foo({\n 1 => 2,\n 3 => 4,\n 5 => 6,\n })" + formats "break 1" formats "break 1" + formats "::foo(1, 2)" formats "::foo(1, 2)" + formats "foo &.bar do\n 1 + 2\nend" formats "foo &.bar do\n 1 + 2\nend" + formats "if a\n2\nelse\n3\nend" formats "if a\n2\nelse\n3\nend" + formats "->{\n # first comment\n puts \"hi\"\n # second comment\n}" formats "->{\n # first comment\n puts \"hi\"\n # second comment\n}" + formats "foo : (A -> B)\nbar : C" formats "foo : (A -> B)\nbar : C" + formats "def foo(\nx, #foo\nz #bar\n)\nend" formats "def foo(\nx, #foo\nz #bar\n)\nend" + formats "foo 1,\na: 1,\nb: 2,\nc: 3" formats "foo 1,\na: 1,\nb: 2,\nc: 3" + formats "::Pointer(T)" formats "::Pointer(T)" + formats "select\n# when foo\nwhen bar\n break\nend" formats "select\n# when foo\nwhen bar\n break\nend" + formats "bar = foo(->do\n 1 + 2\nend)" formats "bar = foo(->do\n 1 + 2\nend)" + formats "foo(\n <<-HERE,\n hello\n HERE\n # foo\n foo: 1,\n)" formats "foo(\n <<-HERE,\n hello\n HERE\n # foo\n foo: 1,\n)" + formats "foo(1, / /)" formats "foo(1, / /)" + formats "case 1\nelse\n 2\nend" formats "case 1\nelse\n 2\nend" + formats "{ {1 => 2} }" formats "{ {1 => 2} }" + formats "# ```text\n# 1 + 2\n# ```" formats "# ```text\n# 1 + 2\n# ```" + formats "def foo ( x ,\n y ) \n end" formats "def foo ( x ,\n y ) \n end" + formats "begin\n # Comment\n\n\nend" formats "begin\n # Comment\n\n\nend" + formats "1 ?\n 2 : \n 3" formats "1 ?\n 2 : \n 3" + formats "if a\n # hello\n 2\nend" formats "if a\n # hello\n 2\nend" + formats "case 0\nwhen 0 then 1; 2\n# Comments\nend" formats "case 0\nwhen 0 then 1; 2\n# Comments\nend" + formats "true" formats "true" + formats "x = <<-EOF\n 1\nEOF" formats "x = <<-EOF\n 1\nEOF" + formats "1234 # foo\n1 # bar" formats "1234 # foo\n1 # bar" + formats "while 1\n2 # foo\nend" formats "while 1\n2 # foo\nend" + formats "foo.as? ( Int32* )" formats "foo.as? ( Int32* )" + formats "break" formats "break" + formats "begin\n ()\nend" formats "begin\n ()\nend" + formats "@[Foo(\n foo: 1\n)]\ndef foo\nend" formats "@[Foo(\n foo: 1\n)]\ndef foo\nend" + formats "1 \\\nensure 2" formats "1 \\\nensure 2" + formats "a = case 1\n when 1, # 1\n 2, # 2\n 3 # 3\n 1\n end" formats "a = case 1\n when 1, # 1\n 2, # 2\n 3 # 3\n 1\n end" + formats "def foo(x)\n {% if true %}\n # comment\n Foo = 1\n B = 2\n {% end %}\nend" formats "def foo(x)\n {% if true %}\n # comment\n Foo = 1\n B = 2\n {% end %}\nend" + formats "foo(\n [\n 1,\n 2,\n ],\n [\n 3,\n 4,\n ]\n)" formats "foo(\n [\n 1,\n 2,\n ],\n [\n 3,\n 4,\n ]\n)" + formats "macro foo=(x)\nend" formats "macro foo=(x)\nend" + formats "a = / /" formats "a = / /" + formats "macro foo\n if 1\n 1 + 2\n end\nend" formats "macro foo\n if 1\n 1 + 2\n end\nend" + formats "1\n# hello\n\n\n" formats "1\n# hello\n\n\n" + formats "-> :: Foo . foo!" formats "-> :: Foo . foo!" + formats "def foo ( @select) \n end" formats "def foo ( @select) \n end" + formats "#### ###" formats "#### ###" + formats "foo(a: 1 // 2)" formats "foo(a: 1 // 2)" + formats "def foo(**z, &block)\nend" formats "def foo(**z, &block)\nend" + formats "foo(\n 1,\n 2\n) do\n 1\nend" formats "foo(\n 1,\n 2\n) do\n 1\nend" + formats "next { 1 , 2 }" formats "next { 1 , 2 }" + formats "-> : Int32 | String { 1 }" formats "-> : Int32 | String { 1 }" + formats "def foo(x : ( A | B )) : ( A | B )\nend" formats "def foo(x : ( A | B )) : ( A | B )\nend" + formats "return( 1 )" formats "return( 1 )" + formats "foo[1, &.bar]?" formats "foo[1, &.bar]?" + formats "extend Foo" formats "extend Foo" + formats "asm(\"a\" : \"b\"(c) : \"d\"(e)\n : \"f\")" formats "asm(\"a\" : \"b\"(c) : \"d\"(e)\n : \"f\")" + formats "foo : Foo * * * * *" formats "foo : Foo * * * * *" + formats "{1 => 2, 3 => 4}\n{5234234 => 234098234, 7 => 8}" formats "{1 => 2, 3 => 4}\n{5234234 => 234098234, 7 => 8}" + formats "a.b &.[c]?\n1" formats "a.b &.[c]?\n1" + formats "fun foo(x : Int32) : Int32\n 1\nend" formats "fun foo(x : Int32) : Int32\n 1\nend" + formats "foo.bar do\n baz\n .b\nend" formats "foo.bar do\n baz\n .b\nend" + formats "case\n# hello\nwhen 1\n 2\nend" formats "case\n# hello\nwhen 1\n 2\nend" + formats "x.try &.[]= 123, 456" formats "x.try &.[]= 123, 456" + formats "foo( 1 , 2 )" formats "foo( 1 , 2 )" + formats "return 1, {2, 3}" formats "return 1, {2, 3}" + formats "->( x , y ) { x }" formats "->( x , y ) { x }" + formats "foo &.[]?(1, 2)" formats "foo &.[]?(1, 2)" + formats "def foo(@[AnnOne] @[AnnTwo] &block : Int32 -> ); end" formats "def foo(@[AnnOne] @[AnnTwo] &block : Int32 -> ); end" + formats "lib Foo\nfun foo(x : Int32, ... ) : Int32\nend" formats "lib Foo\nfun foo(x : Int32, ... ) : Int32\nend" + formats "->( ){ x }" formats "->( ){ x }" + formats "if 1 &&\n2 &&\n3\n4\nend" formats "if 1 &&\n2 &&\n3\n4\nend" + formats "case / /\nwhen /x/, / /\n / /\nend" formats "case / /\nwhen /x/, / /\n / /\nend" + formats "def foo ( bar @select) \n end" formats "def foo ( bar @select) \n end" + formats "x = {% if flag?(:foo) %}\n foo + bar\n {% else %}\n baz + qux\n {% end %}" formats "x = {% if flag?(:foo) %}\n foo + bar\n {% else %}\n baz + qux\n {% end %}" + formats "lib Foo\n fun foo =\n \"bar\"(Int32) : Int32\nend" formats "lib Foo\n fun foo =\n \"bar\"(Int32) : Int32\nend" + formats "foo(\"bar\": 1, \"baz qux\": 2)" formats "foo(\"bar\": 1, \"baz qux\": 2)" + formats "bar = foo([\n 1,\n 2,\n 3,\n])" formats "bar = foo([\n 1,\n 2,\n 3,\n])" + formats "foo = 1\n->foo.bar=(Int32)" formats "foo = 1\n->foo.bar=(Int32)" + formats "foo do | x , y | \n x \n end" formats "foo do | x , y | \n x \n end" + formats "{1, 2, 3}" formats "{1, 2, 3}" + formats "if 1\n[\n a() # b\n]\nend" formats "if 1\n[\n a() # b\n]\nend" + formats "self.as(Int32)" formats "self.as(Int32)" + formats "if 1\ncase 1\nwhen 2\n3\nend\nend" formats "if 1\ncase 1\nwhen 2\n3\nend\nend" + formats "next 1, {2, 3}" formats "next 1, {2, 3}" + formats "lib Foo\nstruct Foo\nx : Int32\ny : Float64\nend\nend" formats "lib Foo\nstruct Foo\nx : Int32\ny : Float64\nend\nend" + formats "foo(1,\n &.bar)" formats "foo(1,\n &.bar)" + formats "macro foo(\n a,\n *b,\n)\nend" formats "macro foo(\n a,\n *b,\n)\nend" + formats "1.<= { 3 }" formats "1.<= { 3 }" + formats "if a\n2; 3\nelse\n3\nend" formats "if a\n2; 3\nelse\n3\nend" + formats "! 1" formats "! 1" + formats "foo(\n 1,\n) {\n 2\n}" formats "foo(\n 1,\n) {\n 2\n}" + formats "def foo(@[MyAnn] & : String -> Nil); end" formats "def foo(@[MyAnn] & : String -> Nil); end" + formats "begin\n select\n when foo\n # foo\n # bar\n else\n # foo\n # bar\n end\nend" formats "begin\n select\n when foo\n # foo\n # bar\n else\n # foo\n # bar\n end\nend" + formats "1 .. 2" formats "1 .. 2" + formats "->foo" formats "->foo" + formats "foo(/ /)" formats "foo(/ /)" + formats "1.[]=() { 3 }" formats "1.[]=() { 3 }" + formats "foo(A |\nB |\nC)" formats "foo(A |\nB |\nC)" + formats "10 // a" formats "10 // a" + formats "a = foo(baz1 do\nend)" formats "a = foo(baz1 do\nend)" + formats "$~.bar" formats "$~.bar" + formats "{%\n if true\n 1\n else\n 2\n end\n%}" formats "{%\n if true\n 1\n else\n 2\n end\n%}" + formats "x : (A -> )" formats "x : (A -> )" + formats "foo.bar = \n1" formats "foo.bar = \n1" + formats "1 > 2" formats "1 > 2" + formats "\"\#{\"foo\"}\"" formats "\"\#{\"foo\"}\"" + formats "require \"foo\"\n\n@x : Int32\n\nclass Bar\nend" formats "require \"foo\"\n\n@x : Int32\n\nclass Bar\nend" + formats "1 ;\n 2" formats "1 ;\n 2" + formats "def foo()\n1\nend" formats "def foo()\n1\nend" + formats " {%\na = 1\n %}" formats " {%\na = 1\n %}" + formats "foo[] =1" formats "foo[] =1" + formats "def foo(a : T, b : U) forall T, U #\n #\nend" formats "def foo(a : T, b : U) forall T, U #\n #\nend" + formats "def foo(x)\n case self // x\n when 2\n 3\n end\nend" formats "def foo(x)\n case self // x\n when 2\n 3\n end\nend" + formats "class Foo\ndef foo\n1\nensure\n2\nend\nend" formats "class Foo\ndef foo\n1\nensure\n2\nend\nend" + formats "begin\n 0[1] rescue 2 end" formats "begin\n 0[1] rescue 2 end" + formats "%w(one two three)" formats "%w(one two three)" + formats "->( x )\n:\nInt32 { }" formats "->( x )\n:\nInt32 { }" + formats "foo { | ( a, *b , c ) | a }" formats "foo { | ( a, *b , c ) | a }" + formats "struct Foo\n # bar\n # baz\n1\nend" formats "struct Foo\n # bar\n # baz\n1\nend" + formats "long_variable_name = [{\n :foo => 1,\n}, {\n :bar => 2,\n}]" formats "long_variable_name = [{\n :foo => 1,\n}, {\n :bar => 2,\n}]" + formats "abstract def foo\nabstract def bar" formats "abstract def foo\nabstract def bar" + formats "foo 1, a: 1,\nb: 2,\nc: 3,\n&block" formats "foo 1, a: 1,\nb: 2,\nc: 3,\n&block" + formats "inner &.color=(@color)\n1" formats "inner &.color=(@color)\n1" + formats "1.as Int32" formats "1.as Int32" + formats "foo &.responds_to?(:foo).bar" formats "foo &.responds_to?(:foo).bar" + formats "require \"foo\"" formats "require \"foo\"" + formats "foo.bar. as? Int32" formats "foo.bar. as? Int32" + formats "1 == / /" formats "1 == / /" + formats "nil?" formats "nil?" + formats "foo{|x| x}" formats "foo{|x| x}" + formats "%(\n1\n)\n\n{\n 1 => 2,\n 234 => 5,\n}" formats "%(\n1\n)\n\n{\n 1 => 2,\n 234 => 5,\n}" + formats "$0" formats "$0" + formats "# Hello\n#\n# ```cr\n# 1\n# ```\n# Bye" formats "# Hello\n#\n# ```cr\n# 1\n# ```\n# Bye" + formats "{%\n unless true\n 1\n end\n%}" formats "{%\n unless true\n 1\n end\n%}" + formats "x.try &.[] 123" formats "x.try &.[] 123" + formats "<<-FOO\n1\nFOO\n\n{\n 1 => 2,\n 10 => 3,\n}" formats "<<-FOO\n1\nFOO\n\n{\n 1 => 2,\n 10 => 3,\n}" + formats "$?.bar" formats "$?.bar" + formats "->(x : Int32) { }" formats "->(x : Int32) { }" + formats "foo &.responds_to?(:foo)" formats "foo &.responds_to?(:foo)" + formats "if a\nelse\n2\nend" formats "if a\nelse\n2\nend" + formats "foo(\"b\#{1}\" \\\n\"baz\")" formats "foo(\"b\#{1}\" \\\n\"baz\")" + formats "`foo`" formats "`foo`" + formats "<<-HTML\n \#{1}x\n y\n HTML" formats "<<-HTML\n \#{1}x\n y\n HTML" + formats ":&**" formats ":&**" + formats " <<-HTML\n \#{1} \#{2}\n HTML" formats " <<-HTML\n \#{1} \#{2}\n HTML" + formats "def foo\nend\n\n\n\ndef bar\nend" formats "def foo\nend\n\n\n\ndef bar\nend" + formats "@[Foo]" formats "@[Foo]" + formats "def foo(\n **a\n # comment\n)\n 1\nend" formats "def foo(\n **a\n # comment\n)\n 1\nend" + formats "foo do\n {{ foo <<-X\n bar\n X\n }}\nend" formats "foo do\n {{ foo <<-X\n bar\n X\n }}\nend" + formats "asm(\n\"nop\"\n)" formats "asm(\n\"nop\"\n)" + formats "asm(\"a\" : :: : \"volatile\")" formats "asm(\"a\" : :: : \"volatile\")" + formats "foo{}" formats "foo{}" + formats "@foo : Int32 # comment\n\ndef foo\nend" formats "@foo : Int32 # comment\n\ndef foo\nend" + formats "foo[a, b: 2]" formats "foo[a, b: 2]" + formats "@[::Foo::Bar]" formats "@[::Foo::Bar]" + formats "Foo( Bar( ) )" formats "Foo( Bar( ) )" + formats "[\n {\n 1 => 2,\n }, {\n 3 => 4,\n }, {\n 5 => 6,\n },\n]" formats "[\n {\n 1 => 2,\n }, {\n 3 => 4,\n }, {\n 5 => 6,\n },\n]" + formats "def foo\n 1\nend\n\n# Comment\n\ndef bar\n 2\nend" formats "def foo\n 1\nend\n\n# Comment\n\ndef bar\n 2\nend" + formats "foo { | a, ( _ , c ) | a + c }" formats "foo { | a, ( _ , c ) | a + c }" + formats "yield (1).foo" formats "yield (1).foo" + formats "foo[ 1 , 2 ]" formats "foo[ 1 , 2 ]" + formats "foo.[1]" formats "foo.[1]" + formats "while / /\nend" formats "while / /\nend" + formats "->@foo.foo=" formats "->@foo.foo=" + formats "foo x: 1" formats "foo x: 1" + formats "lib Foo\n fun bar = Bar\nend" formats "lib Foo\n fun bar = Bar\nend" + formats "def foo(x : (A | B)) \n end" formats "def foo(x : (A | B)) \n end" + formats "def foo\n@x : Int32\nend" formats "def foo\n@x : Int32\nend" + formats "foo : self?" formats "foo : self?" + formats "1\n\n2" formats "1\n\n2" + formats "foo({\nbar: 1,\n})" formats "foo({\nbar: 1,\n})" + formats "def foo( x , & block : ->)\nend" formats "def foo( x , & block : ->)\nend" + formats "(a).b { }\nc" formats "(a).b { }\nc" + formats "foo : Foo*****" formats "foo : Foo*****" + formats "while 1\n2\nend" formats "while 1\n2\nend" + formats "unless a\nunless b\nelse\n4\nend\nend" formats "unless a\nunless b\nelse\n4\nend\nend" + formats "case 1 \n when 2 \n 3 \n when 4 \n 5 \n end" formats "case 1 \n when 2 \n 3 \n when 4 \n 5 \n end" + formats "->Foo.foo?" formats "->Foo.foo?" + formats "{% begin %}\n \"\n foo\"\n{% end %}" formats "{% begin %}\n \"\n foo\"\n{% end %}" + formats "lib Foo\n fun foo = bar(Int32) : Int32\nend" formats "lib Foo\n fun foo = bar(Int32) : Int32\nend" + formats "yield *1 , *2" formats "yield *1 , *2" + formats "0_u64" formats "0_u64" + formats "\"1\#{\"4\#{\"\#{\"2\"}\"}3\"}3\#{__DIR__}4\#{5}6\"" formats "\"1\#{\"4\#{\"\#{\"2\"}\"}3\"}3\#{__DIR__}4\#{5}6\"" + formats "foo : StaticArray(Foo, 12)[34]" formats "foo : StaticArray(Foo, 12)[34]" + formats "lib Foo\n fun foo = bar(Int32) : Int32\nend" formats "lib Foo\n fun foo = bar(Int32) : Int32\nend" + formats "a = b = 1\na, b =\n b, a" formats "a = b = 1\na, b =\n b, a" + formats "def foo\n <<-FOO\n foo \#{1}\n FOO\nend" formats "def foo\n <<-FOO\n foo \#{1}\n FOO\nend" + formats "->{}" formats "->{}" + formats "def foo ( &@block) \n end" formats "def foo ( &@block) \n end" + formats "def foo(a, **b, # comment\n &block)\nend" formats "def foo(a, **b, # comment\n &block)\nend" + formats "1 # foo\n/ 1 /" formats "1 # foo\n/ 1 /" + formats "yield(\n1 , \n2)" formats "yield(\n1 , \n2)" + formats "def foo\n1\nensure\n2\nend" formats "def foo\n1\nensure\n2\nend" + formats "-> : Array(Int32) {}" formats "-> : Array(Int32) {}" + formats "(())" formats "(())" + formats "{ \"foo\": 1 }" formats "{ \"foo\": 1 }" + formats "foo([\n 1,\n bar do\n end,\n [\n 2,\n ],\n])" formats "foo([\n 1,\n bar do\n end,\n [\n 2,\n ],\n])" + formats "module Moo ( T )\nend" formats "module Moo ( T )\nend" + formats "# ```\n# macro foo\n# 1\n# end\n# ```\n" formats "# ```\n# macro foo\n# 1\n# end\n# ```\n" + formats "if 1\n1\n\n# foo\nend" formats "if 1\n1\n\n# foo\nend" + formats "asm(\"nop\" ::: \"eax\" )" formats "asm(\"nop\" ::: \"eax\" )" + formats "String?" formats "String?" + formats "[] of Foo" formats "[] of Foo" + formats "\"hel\nlo\"" formats "\"hel\nlo\"" + formats "1 + \\\n2\n3" formats "1 + \\\n2\n3" + formats "foo.bar # comment\n .baz" formats "foo.bar # comment\n .baz" + formats "module Foo\n1\n\n# foo\nend" formats "module Foo\n1\n\n# foo\nend" + formats "foo.as(T).bar" formats "foo.as(T).bar" + formats "alias A = (B) -> C" formats "alias A = (B) -> C" + formats "next *1 ,2" formats "next *1 ,2" + formats "foo a , **b" formats "foo a , **b" + formats "<<-HTML\n \#{\"fo\#{\"o\"}\"}\n HTML" formats "<<-HTML\n \#{\"fo\#{\"o\"}\"}\n HTML" + formats "if 1\nif 2\n3 # foo\nend\nend" formats "if 1\nif 2\n3 # foo\nend\nend" + formats "foo 1,\n2" formats "foo 1,\n2" + formats "__DIR__" formats "__DIR__" + formats "def foo : self | Nil\n nil\nend" formats "def foo : self | Nil\n nil\nend" + formats "def foo\n {{@type}}\nend" formats "def foo\n {{@type}}\nend" + formats "[1, 2,\n 3, 4]\n" formats "[1, 2,\n 3, 4]\n" + formats "@[Foo(\n 1,\n)]" formats "@[Foo(\n 1,\n)]" + formats "foo(\n 1, # hola\n2, # chau\n )" formats "foo(\n 1, # hola\n2, # chau\n )" + formats "foo(1 + \n2)" formats "foo(1 + \n2)" + formats "{\n 1 => 2, 3 => 4,\n 567 => 8910,\n}" formats "{\n 1 => 2, 3 => 4,\n 567 => 8910,\n}" + formats "macro foo\n {% if 1 %} 2 {% elsif 3 %} 4 {% else %} 5 {% end %}\nend" formats "macro foo\n {% if 1 %} 2 {% elsif 3 %} 4 {% else %} 5 {% end %}\nend" + formats "a = 1\ncase\nwhen 2\nelse\n a /= 3\nend" formats "a = 1\ncase\nwhen 2\nelse\n a /= 3\nend" + formats "x : Int32 |\nString" formats "x : Int32 |\nString" + formats "def /(x)\n 1\nend" formats "def /(x)\n 1\nend" + formats "def foo ( x , y ) \n end" formats "def foo ( x , y ) \n end" + formats "foo.[] = 1" formats "foo.[] = 1" + formats "%x(foo \#{ bar })" formats "%x(foo \#{ bar })" + formats "{% if z %}\n class Foo\n end\n{% end %}" formats "{% if z %}\n class Foo\n end\n{% end %}" + formats "def foo(\n a,\n b\n)\nend" formats "def foo(\n a,\n b\n)\nend" + formats "macro foo\n macro bar\n \\{% begin %}\n \\\\{% puts %}\n \\{% end %}\n end\nend" formats "macro foo\n macro bar\n \\{% begin %}\n \\\\{% puts %}\n \\{% end %}\n end\nend" + formats "return *1 , *2" formats "return *1 , *2" + formats "%w{one( two( three)}" formats "%w{one( two( three)}" + formats "foo &.bar.nil?" formats "foo &.bar.nil?" + formats "x : (A | B)" formats "x : (A | B)" + formats "-> :: Foo . foo" formats "-> :: Foo . foo" + formats "def foo\n 1\n # Comment\n\n\nend" formats "def foo\n 1\n # Comment\n\n\nend" + formats "begin\n1\nrescue Int32 \n3\nend" formats "begin\n1\nrescue Int32 \n3\nend" + formats "module M\n @[MyAnn(\n 1\n\n )]\nend" formats "module M\n @[MyAnn(\n 1\n\n )]\nend" + formats "1 rescue 2" formats "1 rescue 2" + formats "x : A?" formats "x : A?" + formats "foo(1, # foo\n &.bar)" formats "foo(1, # foo\n &.bar)" + formats "class Bar\nprotected def foo(x)\na=b(c)\nend\nend" formats "class Bar\nprotected def foo(x)\na=b(c)\nend\nend" + formats "begin\n1\nrescue\n3\nensure\n2\nend" formats "begin\n1\nrescue\n3\nensure\n2\nend" + formats "[\n1,\n2,\n3]" formats "[\n1,\n2,\n3]" + formats "a = 1 if 1 == 2 ||\n 3 == 4\n" formats "a = 1 if 1 == 2 ||\n 3 == 4\n" + formats "def foo(x)\n self // x\nend" formats "def foo(x)\n self // x\nend" + formats " macro foo\n end\n\n :+" formats " macro foo\n end\n\n :+" + formats "def foo( x , & block : Int32 ->)\nend" formats "def foo( x , & block : Int32 ->)\nend" + formats ":>>" formats ":>>" + formats "\"\\a\\c\\b\\d\"" formats "\"\\a\\c\\b\\d\"" + formats "while 1 &&\n2 &&\n3\n4\nend" formats "while 1 &&\n2 &&\n3\n4\nend" + formats "long_variable_name = [1, 2, 3,\n 4, 5, 6]" formats "long_variable_name = [1, 2, 3,\n 4, 5, 6]" + formats "\"foo \#{bar}\" \\\n \"baz\"" formats "\"foo \#{bar}\" \\\n \"baz\"" + formats "foo &.bar( 1 , 2 )" formats "foo &.bar( 1 , 2 )" + formats "Union(Int32, String)?" formats "Union(Int32, String)?" + formats "coco.lala\nfoo\n .bar" formats "coco.lala\nfoo\n .bar" + formats "foo.as Int32*" formats "foo.as Int32*" + formats "foo 1 , 2" formats "foo 1 , 2" + formats "1 # foo\n1234 # bar\n\n10 # bar" formats "1 # foo\n1234 # bar\n\n10 # bar" + formats "while 1;\n2; end" formats "while 1;\n2; end" + formats "foo (1), 2" formats "foo (1), 2" + formats "foo.bar(&.baz)" formats "foo.bar(&.baz)" + formats "def foo(a : T, b : U) forall T, U\n #\nend" formats "def foo(a : T, b : U) forall T, U\n #\nend" + formats "def foo(a,\n *b)\nend" formats "def foo(a,\n *b)\nend" + formats "foo[1, &.bar]" formats "foo[1, &.bar]" + formats "a = 1\n;\nb = 2" formats "a = 1\n;\nb = 2" + formats "{1 => foo <<-X\nbar\nX\n}" formats "{1 => foo <<-X\nbar\nX\n}" + formats "next( 1 , 2 )" formats "next( 1 , 2 )" + formats "SomeLib.UppercasedFunCall" formats "SomeLib.UppercasedFunCall" + formats "1 if 2\n# foo\n3" formats "1 if 2\n# foo\n3" + formats "def foo(x) # bar\n # baz\nend" formats "def foo(x) # bar\n # baz\nend" + formats ":+" formats ":+" + formats "asm(\"a\" : \"b\"(c)\n)" formats "asm(\"a\" : \"b\"(c)\n)" + formats "call(foo <<-X\nbar\nX\n)" formats "call(foo <<-X\nbar\nX\n)" + formats "return {1, 2}, {3, 4}" formats "return {1, 2}, {3, 4}" + formats "def foo(@[AnnOne] @[AnnTwo] v); end" formats "def foo(@[AnnOne] @[AnnTwo] v); end" + formats "unless a\n2\n3\nelse\n4\n5\nend" formats "unless a\n2\n3\nelse\n4\n5\nend" + formats "->( x : Int32 , y ) { x }" formats "->( x : Int32 , y ) { x }" + formats "lib Foo\nend" formats "lib Foo\nend" + formats "foo.bar=(2)\n1" formats "foo.bar=(2)\n1" + formats "foo[]" formats "foo[]" + formats "x\n# foo\n\n# bar" formats "x\n# foo\n\n# bar" + formats "foo = 1\n->foo.foo!" formats "foo = 1\n->foo.foo!" + formats "\n# hello\n\n1" formats "\n# hello\n\n1" + formats "->\n:\nInt32\n{\n}" formats "->\n:\nInt32\n{\n}" + formats "return 1" formats "return 1" + formats "begin\n 1 \\\n + 2\n 3\nend" formats "begin\n 1 \\\n + 2\n 3\nend" + formats "if 1\n return foo(\n 1,\n 2,\n )\nend" formats "if 1\n return foo(\n 1,\n 2,\n )\nend" + formats "def foo(\n @[MyAnn]\n bar\n); end" formats "def foo(\n @[MyAnn]\n bar\n); end" + formats ":-" formats ":-" + formats "a = foo(1, 2, {\n foo: 1,\n bar: 2,\n})" formats "a = foo(1, 2, {\n foo: 1,\n bar: 2,\n})" + formats "1_234" formats "1_234" + formats "lib Foo\n fun foo =\n bar(Int32) : Int32\nend" formats "lib Foo\n fun foo =\n bar(Int32) : Int32\nend" + formats "a &.b[c]?" formats "a &.b[c]?" + formats "asm(\"nop\" :: )" formats "asm(\"nop\" :: )" + formats "[\n# foo\n] of String" formats "[\n# foo\n] of String" + formats "0i64" formats "0i64" + formats "case 1\nwhen 2\n#comment\nend" formats "case 1\nwhen 2\n#comment\nend" + formats "1.===(2) { 3 }" formats "1.===(2) { 3 }" + formats "->{\nx\n}" formats "->{\nx\n}" + formats "def foo(x, **z)\nend" formats "def foo(x, **z)\nend" + formats "[ * [ * [ 1 ] ], * \n[ 2] ]" formats "[ * [ * [ 1 ] ], * \n[ 2] ]" + formats "if 1;\n2; end" formats "if 1;\n2; end" + formats "1.!= do\nend" formats "1.!= do\nend" + formats "def foo(x) : Int32 # bar\n # baz\nend" formats "def foo(x) : Int32 # bar\n # baz\nend" + formats "::NamedTuple(T)" formats "::NamedTuple(T)" + formats "\"hel\\nlo\"" formats "\"hel\\nlo\"" + formats "def foo\n\n1\n\nend" formats "def foo\n\n1\n\nend" + formats "[\n <<-EOF,\n foo\n EOF\n <<-BAR,\n bar\n BAR\n]" formats "[\n <<-EOF,\n foo\n EOF\n <<-BAR,\n bar\n BAR\n]" + does not add `&` without flag `method_signature_yield` + formats "def foo(a, **b)\n yield\nend" formats "def foo(a, **b)\n yield\nend" + formats "def foo(\nx,\n)\n yield\nend" formats "def foo(\nx,\n)\n yield\nend" + formats "def foo(x,\n)\n yield\nend" formats "def foo(x,\n)\n yield\nend" + formats "def foo(x,\ny,)\n yield\nend" formats "def foo(x,\ny,)\n yield\nend" + formats "def foo # bar\n yield\nend" formats "def foo # bar\n yield\nend" + formats "def foo\n yield\nend" formats "def foo\n yield\nend" + formats "def foo(\nx)\n yield\nend" formats "def foo(\nx)\n yield\nend" + formats "def foo(x)\n yield\nend" formats "def foo(x)\n yield\nend" + formats "def foo(\n)\n yield\nend" formats "def foo(\n)\n yield\nend" + formats "def foo(\nx, y)\n yield\nend" formats "def foo(\nx, y)\n yield\nend" + formats "def foo()\n yield\nend" formats "def foo()\n yield\nend" + formats "def foo(x ,)\n yield\nend" formats "def foo(x ,)\n yield\nend" + formats "def foo(x\n)\n yield\nend" formats "def foo(x\n)\n yield\nend" + formats "def foo(\nx,\ny)\n yield\nend" formats "def foo(\nx,\ny)\n yield\nend" + formats "def foo(x,\n y)\n yield\nend" formats "def foo(x,\n y)\n yield\nend" + formats "lib LibFoo\n {% begin %}\n fun x = y(Int32)\n {% end %}\nend" formats "lib LibFoo\n {% begin %}\n fun x = y(Int32)\n {% end %}\nend" + formats "foo &.bar.as?(T)" formats "foo &.bar.as?(T)" + formats "if 1\n {% if 2 %} {% end %}\nend" formats "if 1\n {% if 2 %} {% end %}\nend" + formats "<<-HTML\n \#{\"foo\"}\#{1}\n HTML" formats "<<-HTML\n \#{\"foo\"}\#{1}\n HTML" + formats "a=1" formats "a=1" + formats "1.<=(2) { 3 }" formats "1.<=(2) { 3 }" + formats "break( 1 )" formats "break( 1 )" + formats "<<-HTML\n \#{1}x\n HTML" formats "<<-HTML\n \#{1}x\n HTML" + formats "lib Foo\nfun foo(x : Int32, y : Float64) : Int32\nend" formats "lib Foo\nfun foo(x : Int32, y : Float64) : Int32\nend" + formats "foo.bar += \n1" formats "foo.bar += \n1" + formats "-> : Int32 {}" formats "-> : Int32 {}" + formats "enum Foo\nA = 1\nend" formats "enum Foo\nA = 1\nend" + formats "{% if true %}\n # x\n #\n{% end %}\n\n# ```\n# x\n# ```" formats "{% if true %}\n # x\n #\n{% end %}\n\n# ```\n# x\n# ```" + formats "macro foo\n \\{\nend" formats "macro foo\n \\{\nend" + formats "@x[ 1 ] &&= 2" formats "@x[ 1 ] &&= 2" + formats "\"foo \#{ __DIR__ }\"" formats "\"foo \#{ __DIR__ }\"" + formats "foo.bar. as Int32" formats "foo.bar. as Int32" + formats "-> : {Int32, String} {}" formats "-> : {Int32, String} {}" + formats "enum Baz\nA = 1\nFOO = 2\n\nEX = 3\nend" formats "enum Baz\nA = 1\nFOO = 2\n\nEX = 3\nend" + formats "class Foo ( *T, U )\nend" formats "class Foo ( *T, U )\nend" + formats "a = \"\n\"\n1 # 1\n12 # 2\n" formats "a = \"\n\"\n1 # 1\n12 # 2\n" + formats "::Tuple()" formats "::Tuple()" + formats "/foo \#{ bar }/" formats "/foo \#{ bar }/" + formats "macro foo\n {% for x in y %}\\ 2 {% end %}\\\nend" formats "macro foo\n {% for x in y %}\\ 2 {% end %}\\\nend" + formats "foo : (self)?" formats "foo : (self)?" + formats "x = a do\n 1 ||\n 2\nend" formats "x = a do\n 1 ||\n 2\nend" + formats "Foo( x: Int32 , y: Float64 )" formats "Foo( x: Int32 , y: Float64 )" + formats "def foo(**z)\nend" formats "def foo(**z)\nend" + formats "foo(\n 1,\n # 2,\n # 3,\n)" formats "foo(\n 1,\n # 2,\n # 3,\n)" + formats "@x ||= 1" formats "@x ||= 1" + formats "1 ||\n # foo\n 2" formats "1 ||\n # foo\n 2" + formats "begin\n 1\n # Comment\n\n\nend" formats "begin\n 1\n # Comment\n\n\nend" + formats "foo { | a, ( b , c ) | a + b + c }" formats "foo { | a, ( b , c ) | a + b + c }" + formats "foo &.as?(T).bar" formats "foo &.as?(T).bar" + formats "{ 1 => 2 ,\n\n 3 => 4 }" formats "{ 1 => 2 ,\n\n 3 => 4 }" + formats "->{}" formats "->{}" + formats "foo : Pointer(Foo)*" formats "foo : Pointer(Foo)*" + formats "while 1 # foo\nend" formats "while 1 # foo\nend" + formats "()" formats "()" + formats "def foo ( @@x) \n end" formats "def foo ( @@x) \n end" + formats "foo[&.bar] ||= 1" formats "foo[&.bar] ||= 1" + formats "foo &.[]=(1, 2)" formats "foo &.[]=(1, 2)" + formats "def foo\n@x = uninitialized Int32\nend" formats "def foo\n@x = uninitialized Int32\nend" + formats "case nil\nelse nil; nil\n# comment\nend" formats "case nil\nelse nil; nil\n# comment\nend" + formats "foo(->{\n 1 + 2\n})" formats "foo(->{\n 1 + 2\n})" + formats "def foo(@x)\n\nrescue\nend" formats "def foo(@x)\n\nrescue\nend" + formats "unless a\nunless b\n3\nelse\n4\nend\nend" formats "unless a\nunless b\n3\nelse\n4\nend\nend" + formats "#######" formats "#######" + formats "{\n variables => true,\n query => <<-HEREDOC,\n foo\n HEREDOC\n}" formats "{\n variables => true,\n query => <<-HEREDOC,\n foo\n HEREDOC\n}" + formats "macro foo\n {% if 1 %}\\ 2 {% else %}\\ 3 {% end %}\\\nend" formats "macro foo\n {% if 1 %}\\ 2 {% else %}\\ 3 {% end %}\\\nend" + formats "case / /\nwhen / /, /x/\n / /\nend" formats "case / /\nwhen / /, /x/\n / /\nend" + formats "foo 1 , &bar" formats "foo 1 , &bar" + formats "a = foo(bar(\n 1,\n 2,\n))" formats "a = foo(bar(\n 1,\n 2,\n))" + formats "def foo\n1\nrescue\n2\nend" formats "def foo\n1\nrescue\n2\nend" + formats "foo(1, 2, {\n foo: 1,\n bar: 2,\n})" formats "foo(1, 2, {\n foo: 1,\n bar: 2,\n})" + formats "case 1\nwhen 8 then 1\nwhen 16 then 2\nwhen 256 then 3\nwhen 'a' then 5\nwhen \"foo\" then 6\nelse 4\nend" formats "case 1\nwhen 8 then 1\nwhen 16 then 2\nwhen 256 then 3\nwhen 'a' then 5\nwhen \"foo\" then 6\nelse 4\nend" + formats "-> : {x: Int32, y: String} {}" formats "-> : {x: Int32, y: String} {}" + formats "foo 1, a: 1,\nb: 2,\nc: 3" formats "foo 1, a: 1,\nb: 2,\nc: 3" + formats ":\"foo bar\"" formats ":\"foo bar\"" + formats "case 1\nwhen 1 then 1\nwhen 123 then 2\nwhen 1..123 then 3\nelse 4\nend" formats "case 1\nwhen 1 then 1\nwhen 123 then 2\nwhen 1..123 then 3\nelse 4\nend" + formats "foo \\\nbar" formats "foo \\\nbar" + formats "<<-HTML\n hello \n HTML" formats "<<-HTML\n hello \n HTML" + formats "unless a\n2\nelse\n3\nend" formats "unless a\n2\nelse\n3\nend" + formats "macro []=(x, y)\nend" formats "macro []=(x, y)\nend" + formats "asm(\"nop\" : \"a\"(0) : \"b\"(1), \"c\"(2) )" formats "asm(\"nop\" : \"a\"(0) : \"b\"(1), \"c\"(2) )" + formats "foo &.nil?" formats "foo &.nil?" + formats "def +(x)\nend" formats "def +(x)\nend" + formats "def foo(\n @[MyAnn]\n bar\n); end" formats "def foo(\n @[MyAnn]\n bar\n); end" + formats "a &.a.!" formats "a &.a.!" + formats "next { {1, 2}, {3, 4} }, 5" formats "next { {1, 2}, {3, 4} }, 5" + formats "begin\n1\nrescue ex : Int32 | Float64 \n3\nend" formats "begin\n1\nrescue ex : Int32 | Float64 \n3\nend" + formats "class Foo\ndef foo (\nx ,\n y ) \n end\nend" formats "class Foo\ndef foo (\nx ,\n y ) \n end\nend" + formats " ( 1; 2; 3 ) " formats " ( 1; 2; 3 ) " + formats "foo(1, 2,)" formats "foo(1, 2,)" + formats " [ 1 , 2 , 3 ] " formats " [ 1 , 2 , 3 ] " + formats "'\\u{0123}'" formats "'\\u{0123}'" + formats "module Readline\n @@completion_proc : (String -> Array(String)?) | (String -> Array(String)) | Nil\nend" formats "module Readline\n @@completion_proc : (String -> Array(String)?) | (String -> Array(String)) | Nil\nend" + formats "yield 1 , 2" formats "yield 1 , 2" + formats "%(hello)" formats "%(hello)" + formats "[ # foo\n 1,\n]" formats "[ # foo\n 1,\n]" + formats "a = \\\n # foo\n bar(1)" formats "a = \\\n # foo\n bar(1)" + formats "lib Foo\nstruct Foo\nx , y : Int32\nend\nend" formats "lib Foo\nstruct Foo\nx , y : Int32\nend\nend" + formats "lib Foo\nfun foo : Int32\nend" formats "lib Foo\nfun foo : Int32\nend" + formats "{} of A => B\n{} of Foo => Bar" formats "{} of A => B\n{} of Foo => Bar" + formats "def foo(@[MyAnn] &); end" formats "def foo(@[MyAnn] &); end" + formats "Set{ # foo\n 1,\n}" formats "Set{ # foo\n 1,\n}" + formats "[\n 1, 2, # foo\n 3,\n]" formats "[\n 1, 2, # foo\n 3,\n]" + formats "a = [\n1,\n2]" formats "a = [\n1,\n2]" + formats "def foo(\n foo,\n @[MyAnn] &block\n); end" formats "def foo(\n foo,\n @[MyAnn] &block\n); end" + formats "lib Foo\n fun foo(Int32) : Int32\nend" formats "lib Foo\n fun foo(Int32) : Int32\nend" + formats "foo[1, &.bar] ||= 1" formats "foo[1, &.bar] ||= 1" + formats "a || b" formats "a || b" + formats "asm(\"nop\" : \"a\"(0)\n: \"b\"(1),\n\"c\"(2) )" formats "asm(\"nop\" : \"a\"(0)\n: \"b\"(1),\n\"c\"(2) )" + formats "def foo : Int32\n 1\nend" formats "def foo : Int32\n 1\nend" + formats "bar do\n call(foo <<-X\n bar\n X\n )\nend" formats "bar do\n call(foo <<-X\n bar\n X\n )\nend" + formats "X(typeof(begin\n e.is_a?(Y)\nend))" formats "X(typeof(begin\n e.is_a?(Y)\nend))" + formats "break 1 , 2" formats "break 1 , 2" + formats "foo x: 1, y: 2" formats "foo x: 1, y: 2" + formats "foo(\n# x\n1,\n\n# y\nz: 2,\n\n# a\nb: 3)" formats "foo(\n# x\n1,\n\n# y\nz: 2,\n\n# a\nb: 3)" + formats " {{ 1 + 2 }}" formats " {{ 1 + 2 }}" + formats ":*" formats ":*" + formats "->@@foo.foo" formats "->@@foo.foo" + formats "if 1\n2\n3\n# foo\nend" formats "if 1\n2\n3\n# foo\nend" + formats "foo.@bar" formats "foo.@bar" + formats "module Foo\n# nothing\nend" formats "module Foo\n# nothing\nend" + formats "foo &.[]( 1, 2 )" formats "foo &.[]( 1, 2 )" + formats "foo.% bar" formats "foo.% bar" + formats "NamedTuple(a: Int32,)" formats "NamedTuple(a: Int32,)" + formats "@a" formats "@a" + formats "def foo(@[AnnOne] @[AnnTwo] v); end" formats "def foo(@[AnnOne] @[AnnTwo] v); end" + formats "foo(\n <<-HERE,\n hello\n HERE\n foo: 1,\n)" formats "foo(\n <<-HERE,\n hello\n HERE\n foo: 1,\n)" + formats "::StaticArray(T)" formats "::StaticArray(T)" + formats "foo(1, &.bar)" formats "foo(1, &.bar)" + formats "lib LibFoo\n struct Bar\n {% begin %}\n x : Int32\n {% end %}\n end\nend" formats "lib LibFoo\n struct Bar\n {% begin %}\n x : Int32\n {% end %}\n end\nend" + formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n\n @[MyAnn] @[MyAnn] baz,\n\n @[MyAnn]\n @[MyAnn]\n biz\n); end" formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n\n @[MyAnn] @[MyAnn] baz,\n\n @[MyAnn]\n @[MyAnn]\n biz\n); end" + assert assert + formats "__LINE__" formats "__LINE__" + formats "foo &.bar.as(T)" formats "foo &.bar.as(T)" + formats "macro foo # bar\n baz\nend" formats "macro foo # bar\n baz\nend" + formats "(1)" formats "(1)" + formats "[\n a() # b\n]" formats "[\n a() # b\n]" + formats " {{\n1 + 2\n }}" formats " {{\n1 + 2\n }}" + formats "<<-FOO\nfoo\nfoo\nFOO" formats "<<-FOO\nfoo\nfoo\nFOO" + formats "return 1 , *2" formats "return 1 , *2" + formats "1.== do\nend" formats "1.== do\nend" + formats "run(\"a\", 1)" formats "run(\"a\", 1)" + formats "foo[ 1 , 2 ] =3" formats "foo[ 1 , 2 ] =3" + formats "a = begin\n 1\nend\n\na =\nbegin\n 1\nend\n\na = if 1\n 2\nend\n\nb = 1\nb ||= begin\n 2\nend\n\nb ||= if 1\n 2\nend\n\nb += if 1\n 2\nend\n\nb +=\nif 1\n 2\nend\n\na, b = begin\n 1\nend\n\na, b =\nbegin\n 1\nend\n\nc[x] = begin\n 2\nend\n\nc[x] =\nbegin\n 2\nend\n\nc[x] = if 1\n 2\nend\n\nc[x] ||= begin 1\n 2\nend\n\nc[x] ||= if 1\n 2\nend\n\nc[x] += if 1\n 2\nend\n\nc[x] += begin 1\n 2\nend\n\nc[x] +=\nbegin\n 1\n 2\nend\n\nfoo.bar = begin\nend\n\nfoo.bar =\nbegin\nend\n\nfoo.bar = if\n 2\nend\n\nfoo.bar += begin\n 2\nend\n\nfoo.bar += if\n 2\nend\n\n" formats "a = begin\n 1\nend\n\na =\nbegin\n 1\nend\n\na = if 1\n 2\nend\n\nb = 1\nb ||= begin\n 2\nend\n\nb ||= if 1\n 2\nend\n\nb += if 1\n 2\nend\n\nb +=\nif 1\n 2\nend\n\na, b = begin\n 1\nend\n\na, b =\nbegin\n 1\nend\n\nc[x] = begin\n 2\nend\n\nc[x] =\nbegin\n 2\nend\n\nc[x] = if 1\n 2\nend\n\nc[x] ||= begin 1\n 2\nend\n\nc[x] ||= if 1\n 2\nend\n\nc[x] += if 1\n 2\nend\n\nc[x] += begin 1\n 2\nend\n\nc[x] +=\nbegin\n 1\n 2\nend\n\nfoo.bar = begin\nend\n\nfoo.bar =\nbegin\nend\n\nfoo.bar = if\n 2\nend\n\nfoo.bar += begin\n 2\nend\n\nfoo.bar += if\n 2\nend\n\n" + formats "-> :: foo" formats "-> :: foo" + formats "module Foo;end" formats "module Foo;end" + formats "1.===() { 3 }" formats "1.===() { 3 }" + formats "def foo(x y)\nend" formats "def foo(x y)\nend" + formats "def foo\nselect \n when foo \n 2 \n else \n 3 \nend\nend" formats "def foo\nselect \n when foo \n 2 \n else \n 3 \nend\nend" + formats "a = 1\nb, c = 2, 3\n{% begin %}\n a |= 1\n b |= 2\n c |= 3\n{% end %}" formats "a = 1\nb, c = 2, 3\n{% begin %}\n a |= 1\n b |= 2\n c |= 3\n{% end %}" + formats "<<-HTML\n foo\n \#{\"foo\"}\n HTML" formats "<<-HTML\n foo\n \#{\"foo\"}\n HTML" + formats "asm(\"a\" :::: \"volatile\"\n)" formats "asm(\"a\" :::: \"volatile\"\n)" + formats "asm(\"nop\" : \"a\"(0),\n\"b\"(1)\n: \"c\"(2), \"d\"(3) )" formats "asm(\"nop\" : \"a\"(0),\n\"b\"(1)\n: \"c\"(2), \"d\"(3) )" + formats "foo bar:baz, qux:other" formats "foo bar:baz, qux:other" + formats "1 #=> 2" formats "1 #=> 2" + formats "foo (1)" formats "foo (1)" + formats "1 && (\n 2 || 3\n)" formats "1 && (\n 2 || 3\n)" + formats "1.as? Int32" formats "1.as? Int32" + formats "foo" formats "foo" + formats "macro foo\nend" formats "macro foo\nend" + formats "foo(baz1 do\nend)" formats "foo(baz1 do\nend)" + formats "begin\n 1 + \\\n 2\n 3\nend" formats "begin\n 1 + \\\n 2\n 3\nend" + formats "def foo ( x = 1 ) \n end" formats "def foo ( x = 1 ) \n end" + formats "def foo(\n foo,\n @[MyAnn]\n &block\n); end" formats "def foo(\n foo,\n @[MyAnn]\n &block\n); end" + formats "yield" formats "yield" + formats "foo\n.bar\n.baz" formats "foo\n.bar\n.baz" + formats "String???" formats "String???" + formats "foo &bar" formats "foo &bar" + formats "case 1 \n when 2 \n 3 \n else \n 4 \n end" formats "case 1 \n when 2 \n 3 \n else \n 4 \n end" + formats "{ # foo\n 1,\n}" formats "{ # foo\n 1,\n}" + formats "macro foo(x, *, z)\nend" formats "macro foo(x, *, z)\nend" + formats "def foo ( x : Int32 = 1 ) \n end" formats "def foo ( x : Int32 = 1 ) \n end" + formats "p = Foo[\n 1, 2, 3,\n 4, 5, 6\n]\n" formats "p = Foo[\n 1, 2, 3,\n 4, 5, 6\n]\n" + formats "def foo(a, &@b)\nend" formats "def foo(a, &@b)\nend" + formats "lib Foo\ntype Foo = Bar\nend" formats "lib Foo\ntype Foo = Bar\nend" + formats "foo(\n 1,\n # 2,\n 3,\n)" formats "foo(\n 1,\n # 2,\n 3,\n)" + formats "def foo\n1\n2\n# foo\nend" formats "def foo\n1\n2\n# foo\nend" + formats "macro foo\n {%1 + 2%}\\\nend" formats "macro foo\n {%1 + 2%}\\\nend" + formats "[\n 1, # foo\n 3,\n]" formats "[\n 1, # foo\n 3,\n]" + formats "<<-HTML\n \#{1}x\n y\n z\n HTML" formats "<<-HTML\n \#{1}x\n y\n z\n HTML" + formats "class Foo ( T )\nend" formats "class Foo ( T )\nend" + formats "def foo(**a,)\n 1\nend" formats "def foo(**a,)\n 1\nend" + formats "case 1\nwhen \"foo\" ; 3\nwhen \"lalalala\"; 4\nelse 5\nend" formats "case 1\nwhen \"foo\" ; 3\nwhen \"lalalala\"; 4\nelse 5\nend" + formats "case nil\nelse nil; nil # comment\nend" formats "case nil\nelse nil; nil # comment\nend" + formats "if 1\n2 # foo\nend" formats "if 1\n2 # foo\nend" + formats "include Foo" formats "include Foo" + formats "[] of (((Array(T))))" formats "[] of (((Array(T))))" + formats "module Foo ( U, *T ); 1; end" formats "module Foo ( U, *T ); 1; end" + formats " <<-EOF\n 1\n 2\n EOF" formats " <<-EOF\n 1\n 2\n EOF" + formats "macro foo\n{% verbatim do %}1 + 2{% end %}\nend" formats "macro foo\n{% verbatim do %}1 + 2{% end %}\nend" + formats "1.[]= do\nend" formats "1.[]= do\nend" + formats "begin\n1\n2\n3\nend" formats "begin\n1\n2\n3\nend" + formats "x : A | B" formats "x : A | B" + formats "foo.foo1(\n bar\n .bar1\n .bar2)" formats "foo.foo1(\n bar\n .bar1\n .bar2)" + formats "1+2*3" formats "1+2*3" + formats "->foo=" formats "->foo=" + formats "10 / a" formats "10 / a" + formats "def foo(\n **a # comment\n)\n 1\nend" formats "def foo(\n **a # comment\n)\n 1\nend" + formats "case 1\nwhen 2\n 3\n # foo\nelse\n 4\n # bar\nend" formats "case 1\nwhen 2\n 3\n # foo\nelse\n 4\n # bar\nend" + formats "while 1\n# nothing\nend" formats "while 1\n# nothing\nend" + formats "if 1\n foo(\n 1,\n 2 # lala\n )\nend\n" formats "if 1\n foo(\n 1,\n 2 # lala\n )\nend\n" + formats "asm(\"a\" ::: \"f\"\n)" formats "asm(\"a\" ::: \"f\"\n)" + formats "alias Foo= Bar" formats "alias Foo= Bar" + formats "foo[x: 1, &.bar]?" formats "foo[x: 1, &.bar]?" + formats "foo.as ( Int32* )" formats "foo.as ( Int32* )" + formats " <<-HTML\n \#{1}\n HTML" formats " <<-HTML\n \#{1}\n HTML" + formats "1\n.." formats "1\n.." + formats "{ {foo: 2} }" formats "{ {foo: 2} }" + formats "@[Foo]\ndef foo\nend" formats "@[Foo]\ndef foo\nend" + formats "a.b &.[c]\n1" formats "a.b &.[c]\n1" + formats "FOO = 2\nA = 1" formats "FOO = 2\nA = 1" + formats "{x => self // 1}" formats "{x => self // 1}" + formats "asm(\"a\" : \"b\"(c) : \"d\"(e) :: \"volatile\")" formats "asm(\"a\" : \"b\"(c) : \"d\"(e) :: \"volatile\")" + formats "\"hello\"" formats "\"hello\"" + formats "def foo(\n **a\n)\n 1\nend" formats "def foo(\n **a\n)\n 1\nend" + formats "1.>=() { 3 }" formats "1.>=() { 3 }" + formats "foo &.[a] = 1" formats "foo &.[a] = 1" + formats "asm(\n # the assembly template string, following the\n # syntax for LLVM's integrated assembler\n \"nop\" : # output operands\n\"=r\"(foo), \"=r\"(bar) : # input operands\n\"r\"(1), \"r\"(baz) : # names of clobbered registers\n\"eax\", \"memory\" : # optional flags, corresponding to the LLVM IR\n # sideeffect / alignstack / inteldialect / unwind attributes\n\"volatile\", \"alignstack\", \"intel\", \"unwind\"\n)" formats "asm(\n # the assembly template string, following the\n # syntax for LLVM's integrated assembler\n \"nop\" : # output operands\n\"=r\"(foo), \"=r\"(bar) : # input operands\n\"r\"(1), \"r\"(baz) : # names of clobbered registers\n\"eax\", \"memory\" : # optional flags, corresponding to the LLVM IR\n # sideeffect / alignstack / inteldialect / unwind attributes\n\"volatile\", \"alignstack\", \"intel\", \"unwind\"\n)" + formats ":^" formats ":^" + formats "alias A = (B(C, (C | D)) | E)" formats "alias A = (B(C, (C | D)) | E)" + formats "->Foo.foo" formats "->Foo.foo" + formats "def foo\nend;def bar\nend" formats "def foo\nend;def bar\nend" + formats "foo do\n {1 => foo <<-X\n bar\n X\n }\nend" formats "foo do\n {1 => foo <<-X\n bar\n X\n }\nend" + formats "<<-FOO\nbarfoo\nFOO" formats "<<-FOO\nbarfoo\nFOO" + formats "lib Foo\n fun foo =\n \"bar\"(Int32) : Int32\n # comment\nend" formats "lib Foo\n fun foo =\n \"bar\"(Int32) : Int32\n # comment\nend" + formats "1 && # foo\n 2 &&\n 3" formats "1 && # foo\n 2 &&\n 3" + formats "def foo : (A | B(C))\n nil\nend" formats "def foo : (A | B(C))\n nil\nend" + formats "# Here is the doc of a method, and contains an example:\n#\n# ```\n# result = foo\n#\n# puts result\n# ```\ndef foo\n # ...\nend\n" formats "# Here is the doc of a method, and contains an example:\n#\n# ```\n# result = foo\n#\n# puts result\n# ```\ndef foo\n # ...\nend\n" + formats "macro foo\n 1 + 2\nend" formats "macro foo\n 1 + 2\nend" + formats "foo a , b , x: 1" formats "foo a , b , x: 1" + formats "macro foo\n def bar \n end \n end" formats "macro foo\n def bar \n end \n end" + formats "a = if 1\n2\n3\nend" formats "a = if 1\n2\n3\nend" + formats "macro foo\n {% 1 + 2 %}\nend" formats "macro foo\n {% 1 + 2 %}\nend" + formats "def foo(**z : Foo)\nend" formats "def foo(**z : Foo)\nend" + formats "\" \" * 2" formats "\" \" * 2" + formats "foo(<<-X,\na\nX\n 1)" formats "foo(<<-X,\na\nX\n 1)" + formats "def foo(x : X) forall X , Y; end" formats "def foo(x : X) forall X , Y; end" + formats "def foo\n 1 #\nrescue\nend" formats "def foo\n 1 #\nrescue\nend" + formats "a = 1\ndef bar\nend" formats "a = 1\ndef bar\nend" + formats "{\n a: 1,\n foo: bar,\n}" formats "{\n a: 1,\n foo: bar,\n}" + formats "def foo(x : (self)?)\nend" formats "def foo(x : (self)?)\nend" + formats "x : Int32" formats "x : Int32" + formats "[c.x]\n .foo" formats "[c.x]\n .foo" + formats "lib Foo\nstruct Foo\nx , y , z : Int32\nend\nend" formats "lib Foo\nstruct Foo\nx , y , z : Int32\nend\nend" + formats "def run\n\nrescue\n 2\n 3\nend" formats "def run\n\nrescue\n 2\n 3\nend" + formats "1 &&\n2 &&\n3" formats "1 &&\n2 &&\n3" + formats "# foo\na = 1 # bar" formats "# foo\na = 1 # bar" + formats "begin\n1\nrescue ex\n3\nelse\n4\nend" formats "begin\n1\nrescue ex\n3\nelse\n4\nend" + formats "getter foo # comment\n\ndef foo\nend" formats "getter foo # comment\n\ndef foo\nend" + formats "alias Foo::Bar=Baz" formats "alias Foo::Bar=Baz" + formats "-> : Int32[1] {}" formats "-> : Int32[1] {}" + formats "asm(\"nop\" ::: \"eax\" , \"ebx\" )" formats "asm(\"nop\" ::: \"eax\" , \"ebx\" )" + formats "break *1 ,2" formats "break *1 ,2" + formats "foo.bar += 2" formats "foo.bar += 2" + formats "enum Foo : Int32\nA = 1\nend" formats "enum Foo : Int32\nA = 1\nend" + formats "1 \\\n+ 2" formats "1 \\\n+ 2" + formats "macro foo\n {% for x in y %} 2 {% end %}\nend" formats "macro foo\n {% for x in y %} 2 {% end %}\nend" + formats "next 1 , 2" formats "next 1 , 2" + formats "->{}" formats "->{}" + formats "x: Int32" formats "x: Int32" + formats "-> { }" formats "-> { }" + formats "-> :: foo?" formats "-> :: foo?" + formats "foo (1).bar" formats "foo (1).bar" + formats "select \n when foo then 2 \n end" formats "select \n when foo then 2 \n end" + formats "is_a? Foo" formats "is_a? Foo" + formats "foo(\"bar\" \\\n\"baz\")" formats "foo(\"bar\" \\\n\"baz\")" + formats "1 +\n # foo\n 2" formats "1 +\n # foo\n 2" + formats "->@foo.foo!" formats "->@foo.foo!" + formats "asm(\n\"nop\" : \"a\"(0), \"b\"(1) )" formats "asm(\n\"nop\" : \"a\"(0), \"b\"(1) )" + formats "あ.い = 1" formats "あ.い = 1" + formats "%w(\n one two\n three four\n)" formats "%w(\n one two\n three four\n)" + formats "foo\n \nbar" formats "foo\n \nbar" + formats "Union(Foo::Bar?, Baz?, Qux(T, U?))" formats "Union(Foo::Bar?, Baz?, Qux(T, U?))" + formats "\n# hello\n1" formats "\n# hello\n1" + formats "foo \\\n 1,\n 2" formats "foo \\\n 1,\n 2" + formats "foo . is_a? Bar" formats "foo . is_a? Bar" + formats "unless a\n2\nelse\nend" formats "unless a\n2\nelse\nend" + formats "foo &.as(T).bar" formats "foo &.as(T).bar" + formats "x : Int32 = 1" formats "x : Int32 = 1" + formats "def foo(x, *, y, **z)\nend" formats "def foo(x, *, y, **z)\nend" + formats "<<-FOO\nFOO" formats "<<-FOO\nFOO" + formats " case 1\n when 2\n 3\n else #:newline, :eof\n 1 if 2\n return 3\n end\n" formats " case 1\n when 2\n 3\n else #:newline, :eof\n 1 if 2\n return 3\n end\n" + formats "...\n2" formats "...\n2" + formats "select \n when foo \n 2 \n when bar \n 3 \n end" formats "select \n when foo \n 2 \n when bar \n 3 \n end" + formats "class Actor\n macro inherited\n\nend\nend\n" formats "class Actor\n macro inherited\n\nend\nend\n" + formats "foo &.[]" formats "foo &.[]" + formats "->() do x end" formats "->() do x end" + formats "macro foo\n {% if true %}if true{% end %}\n {% if true %}end{% end %}\nend" formats "macro foo\n {% if true %}if true{% end %}\n {% if true %}end{% end %}\nend" + formats "if 1 &&\n (2 || 3)\n 1\nelse\n 2\nend" formats "if 1 &&\n (2 || 3)\n 1\nelse\n 2\nend" + formats "def foo( x , & block : Int32->Float64)\nend" formats "def foo( x , & block : Int32->Float64)\nend" + formats "foo do\n bar do\n foo <<-X\n bar\n X\n end\nend" formats "foo do\n bar do\n foo <<-X\n bar\n X\n end\nend" + formats "x 1, \\\n 2" formats "x 1, \\\n 2" + formats "1\n..2" formats "1\n..2" + formats "{\n 1 => 2,\n 10 => 30,\n 30 => 40,\n \"foobar\" => 50,\n \"coco\" => 60,\n}" formats "{\n 1 => 2,\n 10 => 30,\n 30 => 40,\n \"foobar\" => 50,\n \"coco\" => 60,\n}" + formats "foo.[1, 2] = 3" formats "foo.[1, 2] = 3" + formats "b &.[c]?.d" formats "b &.[c]?.d" + formats "x : {\"foo bar\": Int32}" formats "x : {\"foo bar\": Int32}" + formats " Array( {x: Int32, y: String } )" formats " Array( {x: Int32, y: String } )" + formats "class X; annotation FooAnnotation ; end ; end" formats "class X; annotation FooAnnotation ; end ; end" + formats "foo\n .bar(\n 1\n )" formats "foo\n .bar(\n 1\n )" + formats "case foo\nwhen 1\n # A\nelse\n# B\nend\n" formats "case foo\nwhen 1\n # A\nelse\n# B\nend\n" + formats "abstract def foo \n 1" formats "abstract def foo \n 1" + formats "def foo(\n &block\n)\nend" formats "def foo(\n &block\n)\nend" + formats "foo(a: //, b: //)" formats "foo(a: //, b: //)" + formats "foo((1..3))" formats "foo((1..3))" + formats "foo : ( A | B )" formats "foo : ( A | B )" + formats "foo do\n {% foo <<-X\n bar\n X\n %}\nend" formats "foo do\n {% foo <<-X\n bar\n X\n %}\nend" + formats "lib Foo\nfun foo () : Int32\nend" formats "lib Foo\nfun foo () : Int32\nend" + formats "macro foo\n {{ 1 + 2 }}\nend" formats "macro foo\n {{ 1 + 2 }}\nend" + formats "1\n..\n2" formats "1\n..\n2" + formats "foo(\n 1, 2,\n&block)" formats "foo(\n 1, 2,\n&block)" + formats "module Foo # foo\nend" formats "module Foo # foo\nend" + formats "if / /\nend" formats "if / /\nend" + formats "lib Foo\n fun Foo = Bar\nend" formats "lib Foo\n fun Foo = Bar\nend" + formats "{% if true %}\n # x\n # y\n{% end %}" formats "{% if true %}\n # x\n # y\n{% end %}" + formats "macro foo(\n a,\n **b,\n)\nend" formats "macro foo(\n a,\n **b,\n)\nend" + formats "{ 1 => 2 ,\n 3 => 4 }" formats "{ 1 => 2 ,\n 3 => 4 }" + formats "case 1 \n in Int32 \n 3 \n end" formats "case 1 \n in Int32 \n 3 \n end" + formats "alias X = ((Y, Z) ->)" formats "alias X = ((Y, Z) ->)" + formats "foo &.is_a?(T).bar" formats "foo &.is_a?(T).bar" + formats "-> { 1 }" formats "-> { 1 }" + formats "def foo(x) forall T # bar\n # baz\nend" formats "def foo(x) forall T # bar\n # baz\nend" + formats "1 # foo" formats "1 # foo" + formats "1\n.as?(Int32)" formats "1\n.as?(Int32)" + formats "a = case 1\nwhen 2\n3\nend" formats "a = case 1\nwhen 2\n3\nend" + formats "\"foo\" \\\n \"bar\"" formats "\"foo\" \\\n \"bar\"" + formats "a = while 1\n2\nend" formats "a = while 1\n2\nend" + formats "lib Foo\n fun foo = \"bar\"(Int32) : Int32\nend" formats "lib Foo\n fun foo = \"bar\"(Int32) : Int32\nend" + formats "{ } of A => B" formats "{ } of A => B" + formats "foo . bar( x , y )" formats "foo . bar( x , y )" + formats "case 1\nend" formats "case 1\nend" + formats "def func # comment\n (1 + 2) / 3\nend" formats "def func # comment\n (1 + 2) / 3\nend" + formats "foo.[ 1 , 2 ]" formats "foo.[ 1 , 2 ]" + formats "foo(\n 1,\n) do\n 2\nend" formats "foo(\n 1,\n) do\n 2\nend" + formats "a-1" formats "a-1" + formats "break( *1 , *2 )" formats "break( *1 , *2 )" + formats "\"\#{ # foo\n foo = 1\n}\"" formats "\"\#{ # foo\n foo = 1\n}\"" + formats "def foo( x , & block : Int32 )\nend" formats "def foo( x , & block : Int32 )\nend" + formats "unless a\n2; 3\nelse\n3\nend" formats "unless a\n2; 3\nelse\n3\nend" + formats "foo.\nbar" formats "foo.\nbar" + formats "p = Foo[1, 2, 3,\n 4, 5, 6,\n ]" formats "p = Foo[1, 2, 3,\n 4, 5, 6,\n ]" + formats "case 1 \n when 2 ,\n 3 \n 4 \n end" formats "case 1 \n when 2 ,\n 3 \n 4 \n end" + formats "macro bar\n 1\nend\n\ncase 1\nwhen 2 then 3\nwhen 45 then 6\nend" formats "macro bar\n 1\nend\n\ncase 1\nwhen 2 then 3\nwhen 45 then 6\nend" + formats "enum Foo; A = 1; end" formats "enum Foo; A = 1; end" + formats "[1, 2, 3]" formats "[1, 2, 3]" + formats "case\nelse\n 1\nend" formats "case\nelse\n 1\nend" + formats "def foo( & \n )\nend" formats "def foo( & \n )\nend" + formats "return *1" formats "return *1" + formats ":/" formats ":/" + formats "if 1\nfoo do | x , y | \n x \n end\nend" formats "if 1\nfoo do | x , y | \n x \n end\nend" + formats "def foo(\n @[MyAnn]\n bar\n); end" formats "def foo(\n @[MyAnn]\n bar\n); end" + formats "1\n2\n# foo" formats "1\n2\n# foo" + formats "a = 1;;; b = 2" formats "a = 1;;; b = 2" + formats "alias A = ( A | B )" formats "alias A = ( A | B )" + formats "foo = 1\n->foo.[](Int32)" formats "foo = 1\n->foo.[](Int32)" + formats "foo.[ 1 , 2 ] =3" formats "foo.[ 1 , 2 ] =3" + formats "Set { 1 , 2 }" formats "Set { 1 , 2 }" + formats " {% for x in y %} 2 {% end %}" formats " {% for x in y %} 2 {% end %}" + formats "# Hello\n#\n# ```crystal\n# 1\n# ```\n# Bye" formats "# Hello\n#\n# ```crystal\n# 1\n# ```\n# Bye" + formats "NamedTuple(\n a: Int32,\n)" formats "NamedTuple(\n a: Int32,\n)" + formats "foo &.bar" formats "foo &.bar" + formats "1 + # foo\n2" formats "1 + # foo\n2" + formats "->{ x }" formats "->{ x }" + formats "def foo( x , & : Int32 )\nend" formats "def foo( x , & : Int32 )\nend" + formats "10 ** a" formats "10 ** a" + formats "# foo\ndef foo\nend\n# bar\ndef bar\nend" formats "# foo\ndef foo\nend\n# bar\ndef bar\nend" + formats "FOO = 2 + 3\nA = 1 - 10" formats "FOO = 2 + 3\nA = 1 - 10" + formats "foo.as? Int32*" formats "foo.as? Int32*" + formats "->(x : Int32) {}" formats "->(x : Int32) {}" + formats "class Foo\n macro foo\n 1 + 2 \n end\n end" formats "class Foo\n macro foo\n 1 + 2 \n end\n end" + formats "args.any? &.name.baz" formats "args.any? &.name.baz" + formats "1.==() { 3 }" formats "1.==() { 3 }" + formats "1 + \\\n2" formats "1 + \\\n2" + formats "1.!= { 3 }" formats "1.!= { 3 }" + formats " 1" formats " 1" + formats "<<-HEREDOC\n \#{foo}\n H\#{bar}\n HEREDOC" formats "<<-HEREDOC\n \#{foo}\n H\#{bar}\n HEREDOC" + formats "{ 1 => 2 , 3 => 4 }" formats "{ 1 => 2 , 3 => 4 }" + formats "macro foo\n {{ 1 + 2 }}\\\nend" formats "macro foo\n {{ 1 + 2 }}\\\nend" + formats "if 1\nelse\n2 # foo\nend" formats "if 1\nelse\n2 # foo\nend" + formats "unless a\n2\n3\nend" formats "unless a\n2\n3\nend" + formats "def foo\n case x\n # z\n when 1\n end\nend" formats "def foo\n case x\n # z\n when 1\n end\nend" + formats "Foo::Bar?" formats "Foo::Bar?" + formats "foo \\\n foo: 1,\n bar: 2" formats "foo \\\n foo: 1,\n bar: 2" + formats "{\n query => <<-HEREDOC,\n foo\n HEREDOC\n}" formats "{\n query => <<-HEREDOC,\n foo\n HEREDOC\n}" + formats "def foo(x = __FILE__ )\nend" formats "def foo(x = __FILE__ )\nend" + formats "10**a" formats "10**a" + formats "join io, &.inspect" formats "join io, &.inspect" + formats "def foo \n end" formats "def foo \n end" + formats "while true\n1\n\n# foo\nend" formats "while true\n1\n\n# foo\nend" + formats "fun foo(\n x : Int32,\n ...\n) : Int32\n 1\nend" formats "fun foo(\n x : Int32,\n ...\n) : Int32\n 1\nend" + formats "{\n1 => 2 ,\n 3 => 4 }" formats "{\n1 => 2 ,\n 3 => 4 }" + formats "begin 0[1] rescue 2 end" formats "begin 0[1] rescue 2 end" + formats "enum Foo\n A; B; C\nend\n" formats "enum Foo\n A; B; C\nend\n" + formats "Foo( x: Int32 )" formats "Foo( x: Int32 )" + formats "enum Foo;end" formats "enum Foo;end" + formats "foo &.nil?()" formats "foo &.nil?()" + formats "a = foo(bar([\n 1,\n]))" formats "a = foo(bar([\n 1,\n]))" + formats "def foo( x , & block )\nend" formats "def foo( x , & block )\nend" + formats "def foo(\n @[MyAnn] bar\n); end" formats "def foo(\n @[MyAnn] bar\n); end" + formats "-> : Int32 { }" formats "-> : Int32 { }" + formats "Foo" formats "Foo" + formats "as Foo" formats "as Foo" + formats "&+ 1" formats "&+ 1" + formats "$~ = 1" formats "$~ = 1" + formats "@[Foo()]" formats "@[Foo()]" + formats "a &.b.c.as(C)" formats "a &.b.c.as(C)" + formats "1 +\n # foo\n 2" formats "1 +\n # foo\n 2" + formats "a &.b.c.as C" formats "a &.b.c.as C" + formats "if 1\n2\nend\nif 3\nend" formats "if 1\n2\nend\nif 3\nend" + formats "1.>= { 3 }" formats "1.>= { 3 }" + formats "asm(\"nop\" ::: \"eax\" , \"ebx\" : \"volatile\" , \"alignstack\" )" formats "asm(\"nop\" ::: \"eax\" , \"ebx\" : \"volatile\" , \"alignstack\" )" + formats "foo : (String -> Array(String)?) | (String -> Array(String)) | Nil" formats "foo : (String -> Array(String)?) | (String -> Array(String)) | Nil" + formats "a = # foo\n bar(1)" formats "a = # foo\n bar(1)" + formats "\n# hello\n\n\n1" formats "\n# hello\n\n\n1" + formats "enum Foo\n A = 10\n FOO = 123\n BARBAZ = 1234\nend\n" formats "enum Foo\n A = 10\n FOO = 123\n BARBAZ = 1234\nend\n" + formats "a = \nif 1\n2\nend" formats "a = \nif 1\n2\nend" + formats "lib Bar\n enum Foo\n A = 1\n end\nend" formats "lib Bar\n enum Foo\n A = 1\n end\nend" + formats "-> : Int32 {}" formats "-> : Int32 {}" + formats "break *1 , *2" formats "break *1 , *2" + formats "def foo ( @x, @y) \n end" formats "def foo ( @x, @y) \n end" + formats "{% verbatim do %}\n <<-FOO\n hello \n FOO\n{% end %}" formats "{% verbatim do %}\n <<-FOO\n hello \n FOO\n{% end %}" + formats "-> :: foo=" formats "-> :: foo=" + formats "10//a" formats "10//a" + formats "\"\" + <<-END\n bar\n END" formats "\"\" + <<-END\n bar\n END" + formats "foo a: 1\nb" formats "foo a: 1\nb" + formats "def foo(@[MyAnn] v); end" formats "def foo(@[MyAnn] v); end" + formats "def foo(a : T) forall T\n #\n\n\nend" formats "def foo(a : T) forall T\n #\n\n\nend" + formats "def foo ( ) \n1\nend" formats "def foo ( ) \n1\nend" + formats "def a\n b(\n 1, # x\n # y\n 2\n )\nend" formats "def a\n b(\n 1, # x\n # y\n 2\n )\nend" + formats "foo . bar = 1" formats "foo . bar = 1" + formats "lib Foo\n $foo = hello : Int32 \nend" formats "lib Foo\n $foo = hello : Int32 \nend" + formats "macro foo()\nend" formats "macro foo()\nend" + formats "foo.%(bar)" formats "foo.%(bar)" + formats "1.== { 3 }" formats "1.== { 3 }" + formats "if 1\n foo(\n bar\n # comment\n )\nend" formats "if 1\n foo(\n bar\n # comment\n )\nend" + formats "$0.bar" formats "$0.bar" + formats "{%\n unless true\n 1\n else\n 2\n end\n%}" formats "{%\n unless true\n 1\n else\n 2\n end\n%}" + formats "foo . is_a? ( Bar )" formats "foo . is_a? ( Bar )" + formats "as? Foo" formats "as? Foo" + formats "{\n foo: 1,\n b: 2,\n barbaz: 3,\n}" formats "{\n foo: 1,\n b: 2,\n barbaz: 3,\n}" + formats "A = 1\nFOO = 2\n\nEX = 3" formats "A = 1\nFOO = 2\n\nEX = 3" + formats "foo &.>=(2)" formats "foo &.>=(2)" + formats "enum E\n A # hello\n B # hello; C # hello\nend" formats "enum E\n A # hello\n B # hello; C # hello\nend" + formats "foo = [1, [2,\n 3],\n 4]" formats "foo = [1, [2,\n 3],\n 4]" + formats "[] of (Array(T))" formats "[] of (Array(T))" + formats "return" formats "return" + formats "asm(\"nop\" :::: \"volatile\" )" formats "asm(\"nop\" :::: \"volatile\" )" + formats "\"foo\#{\"bar\"} Baz \#{\"qux\"} \"" formats "\"foo\#{\"bar\"} Baz \#{\"qux\"} \"" + formats "Tuple()" formats "Tuple()" + formats "foo { | a, ( b , (c, d) ) | a + b + c }" formats "foo { | a, ( b , (c, d) ) | a + b + c }" + formats "x.is_a? T\n3\n" formats "x.is_a? T\n3\n" + formats "1 && 2" formats "1 && 2" + formats "-> :: Foo . foo?" formats "-> :: Foo . foo?" + formats "b &.[c].d" formats "b &.[c].d" + formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n @[MyAnn] @[MyAnn] baz,\n @[MyAnn]\n @[MyAnn]\n biz\n); end" formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n @[MyAnn] @[MyAnn] baz,\n @[MyAnn]\n @[MyAnn]\n biz\n); end" + formats "foo(\n # foo\n1,\n\n # bar\n2, \n)" formats "foo(\n # foo\n1,\n\n # bar\n2, \n)" + formats "foo { | a, ( b , c, ), | a + b + c }" formats "foo { | a, ( b , c, ), | a + b + c }" + formats "next *1 , *2" formats "next *1 , *2" + formats " <<-EOF\n 1\n EOF" formats " <<-EOF\n 1\n EOF" + formats "begin\n array[\n 0 # Zero\n ]\nend" formats "begin\n array[\n 0 # Zero\n ]\nend" + formats "{/ / => / /, / / => / /}" formats "{/ / => / /, / / => / /}" + formats "def foo(x @y)\nend" formats "def foo(x @y)\nend" + formats "Foo:: Bar" formats "Foo:: Bar" + formats "foo(baz(x, y) do\n 1 + 2\nend)" formats "foo(baz(x, y) do\n 1 + 2\nend)" + formats "+ a + d" formats "+ a + d" + formats "class Foo\n NamedTuple(\n a: Int32,\n )\nend" formats "class Foo\n NamedTuple(\n a: Int32,\n )\nend" + formats "@[Foo(\n foo: 1,\n)]\ndef foo\nend" formats "@[Foo(\n foo: 1,\n)]\ndef foo\nend" + formats "case 1\nwhen 2\n\n#comment\nend" formats "case 1\nwhen 2\n\n#comment\nend" + formats "foo : (String -> String?) | (String)" formats "foo : (String -> String?) | (String)" + formats "def a\n [\n 1, # x\n # y\n ]\nend" formats "def a\n [\n 1, # x\n # y\n ]\nend" + formats "def foo\n 1\n #\n\n\nrescue\nend" formats "def foo\n 1\n #\n\n\nrescue\nend" + formats "[\n1, # a\n2, # b\n 3 # c\n]" formats "[\n1, # a\n2, # b\n 3 # c\n]" + formats "def self . foo\nend" formats "def self . foo\nend" + formats "{{ foo <<-X\nbar\nX\n}}" formats "{{ foo <<-X\nbar\nX\n}}" + formats "next( *1 , *2 )" formats "next( *1 , *2 )" + formats "def foo\n ((((((((((((((((0_u64\n ) | ptr[0]) << 8\n ) | ptr[1]) << 8\n ) | ptr[2]) << 8\n ) | ptr[3]) << 8\n ) | ptr[4]) << 8\n ) | ptr[5]) << 8\n ) | ptr[6]) << 8\n ) | ptr[7])\nend" formats "def foo\n ((((((((((((((((0_u64\n ) | ptr[0]) << 8\n ) | ptr[1]) << 8\n ) | ptr[2]) << 8\n ) | ptr[3]) << 8\n ) | ptr[4]) << 8\n ) | ptr[5]) << 8\n ) | ptr[6]) << 8\n ) | ptr[7])\nend" + formats "a , b = 1 , 2" formats "a , b = 1 , 2" + formats "1.[]= { 3 }" formats "1.[]= { 3 }" + formats "def execute\n begin\n 1\n ensure\n 2\n end\n 3\nend" formats "def execute\n begin\n 1\n ensure\n 2\n end\n 3\nend" + formats "foo.bar.baz\n.qux" formats "foo.bar.baz\n.qux" + formats "foo &.as(T)" formats "foo &.as(T)" + formats "@x[ 1 ] ||= 2" formats "@x[ 1 ] ||= 2" + formats "foo(a: //)" formats "foo(a: //)" + formats "foo(1, 2,\n)" formats "foo(1, 2,\n)" + formats "1 if 2\n# foo" formats "1 if 2\n# foo" + formats "case 1\nwhen 2 # a\n # b\nend" formats "case 1\nwhen 2 # a\n # b\nend" + formats "begin\n begin\n a\n # b\n end\nend" formats "begin\n begin\n a\n # b\n end\nend" + formats "foo.bar\n .baz(\n 1\n )" formats "foo.bar\n .baz(\n 1\n )" + formats " {% if 1 %} 2 {% end %}" formats " {% if 1 %} 2 {% end %}" + formats "1 + \\\n2 + \\\n3" formats "1 + \\\n2 + \\\n3" + formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n\n @[MyAnn] @[MyAnn] baz,\n\n @[MyAnn]\n\n @[MyAnn]\n\n biz\n); end" formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar,\n\n @[MyAnn] @[MyAnn] baz,\n\n @[MyAnn]\n\n @[MyAnn]\n\n biz\n); end" + formats "foo = 1\n->foo.foo" formats "foo = 1\n->foo.foo" + formats "\"\\\\\\\"\\#\\a\\b\\n\\r\\t\\v\\f\\e\"" formats "\"\\\\\\\"\\#\\a\\b\\n\\r\\t\\v\\f\\e\"" + formats "~ 1" formats "~ 1" + formats "1#foo" formats "1#foo" + formats "foo(bar(\n 1,\n 2,\n))" formats "foo(bar(\n 1,\n 2,\n))" + formats "macro foo\n %foo{x,y}\nend" formats "macro foo\n %foo{x,y}\nend" + formats "alias Foo::Bar =Baz" formats "alias Foo::Bar =Baz" + formats "$1.bar" formats "$1.bar" + formats " {% if 1 %} {% if 2 %} 2 {% end %} {% end %}" formats " {% if 1 %} {% if 2 %} 2 {% end %} {% end %}" + formats "[1,\n2,\n3]" formats "[1,\n2,\n3]" + formats "case 1\nwhen 1 then\n2\nwhen 3\n4\nend" formats "case 1\nwhen 1 then\n2\nwhen 3\n4\nend" + formats "macro flags\n {% if 1 %}\\\n 1 {% else %}\\\n {% end %}\\\nend" formats "macro flags\n {% if 1 %}\\\n 1 {% else %}\\\n {% end %}\\\nend" + formats "{ {% begin %}1{% end %}, nil }" formats "{ {% begin %}1{% end %}, nil }" + formats "1 ... 2" formats "1 ... 2" + formats "(1 .. )" formats "(1 .. )" + formats "foo()" formats "foo()" + formats "case 1\nwhen \"foo\" then 3\nwhen \"lalalala\" then 4\nelse 5\nend" formats "case 1\nwhen \"foo\" then 3\nwhen \"lalalala\" then 4\nelse 5\nend" + formats "def foo\nend\ndef bar\nend" formats "def foo\nend\ndef bar\nend" + formats "a.!" formats "a.!" + formats "lib Foo\nfun foo\nend" formats "lib Foo\nfun foo\nend" + formats "" formats "" + formats "def foo : Int32 \n end" formats "def foo : Int32 \n end" + formats "page= <<-HTML\n \#{1}foo\nHTML" formats "page= <<-HTML\n \#{1}foo\nHTML" + formats "[1,\n2,\n3\n]" formats "[1,\n2,\n3\n]" + formats "<<-FOO\nfoobar\nFOO" formats "<<-FOO\nfoobar\nFOO" + formats "class Foo # foo\nend" formats "class Foo # foo\nend" + formats "def foo ( @@select) \n end" formats "def foo ( @@select) \n end" + formats "->@@foo.foo!" formats "->@@foo.foo!" + formats "foo.responds_to? :bar\n1" formats "foo.responds_to? :bar\n1" + formats "class Foo\n@x : Int32\nend" formats "class Foo\n@x : Int32\nend" + formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar\n); end" formats "def foo(\n @[MyAnn]\n @[MyAnn]\n bar\n); end" + formats "alias Foo=Bar" formats "alias Foo=Bar" + formats "lib Bar\n enum Foo\n end\nend" formats "lib Bar\n enum Foo\n end\nend" + formats "foo{|x|\n x}" formats "foo{|x|\n x}" + formats "a&-1" formats "a&-1" + formats "alias Foo::Bar= Baz" formats "alias Foo::Bar= Baz" + formats "lib Foo\nfun foo(x : Int32,\ny : Float64) : Int32\nend" formats "lib Foo\nfun foo(x : Int32,\ny : Float64) : Int32\nend" + formats "begin\n call\n # comment\nrescue\n call\n # comment\nelse\n call\n # comment\nensure\n call\n # comment\nend" formats "begin\n call\n # comment\nrescue\n call\n # comment\nelse\n call\n # comment\nensure\n call\n # comment\nend" + formats " {%\na = 1 %}" formats " {%\na = 1 %}" + formats "1.=== { 3 }" formats "1.=== { 3 }" + formats "lib Foo\n fun foo =\n bar(Int32,\n Int32) : Int32\nend" formats "lib Foo\n fun foo =\n bar(Int32,\n Int32) : Int32\nend" + formats "yield 1" formats "yield 1" + formats "def foo ( x ) \n end" formats "def foo ( x ) \n end" + formats "def foo\n {% if flag?(:foo) %}\n foo + bar\n {% else %}\n baz + qux\n {% end %}\nend" formats "def foo\n {% if flag?(:foo) %}\n foo + bar\n {% else %}\n baz + qux\n {% end %}\nend" + formats "[foo <<-X\nbar\nX\n]" formats "[foo <<-X\nbar\nX\n]" + formats "{% for a in %w() %}\n <<-FOO\n hello \n FOO\n{% end %}" formats "{% for a in %w() %}\n <<-FOO\n hello \n FOO\n{% end %}" + formats "case 1\nelse # foo\n # bar\nend" formats "case 1\nelse # foo\n # bar\nend" + formats " _ , *_ ,\na.foo ,a.bar = 1 , 2,3" formats " _ , *_ ,\na.foo ,a.bar = 1 , 2,3" + formats "break { 1 , 2 }" formats "break { 1 , 2 }" + formats "lib Foo\n $foo : Int32 \nend" formats "lib Foo\n $foo : Int32 \nend" + formats "asm(\"nop\" : \"a\"(0) )" formats "asm(\"nop\" : \"a\"(0) )" + formats "x = <<-FOO\n hello\n FOO\n\ndef bar\nend" formats "x = <<-FOO\n hello\n FOO\n\ndef bar\nend" + formats "def foo(a,\n &block)\nend" formats "def foo(a,\n &block)\nend" + formats "foo\n .bar\n .baz(\n 1\n )" formats "foo\n .bar\n .baz(\n 1\n )" + formats "alias A = ((B(C | D) | E) | F)" formats "alias A = ((B(C | D) | E) | F)" + formats "a = 1 + # foo\n2" formats "a = 1 + # foo\n2" + formats " [ 1, \n 2 , \n 3 ] " formats " [ 1, \n 2 , \n 3 ] " + formats "class Foo\n macro foo\n 1\n end\nend" formats "class Foo\n macro foo\n 1\n end\nend" + formats "$1" formats "$1" + formats "bla.select(&.all?{ |x| x } )" formats "bla.select(&.all?{ |x| x } )" + formats ":&-" formats ":&-" + formats "case 1 \n when 2 ;\n 3 \n end" formats "case 1 \n when 2 ;\n 3 \n end" + formats "$~" formats "$~" + formats "Foo(\"bar\": Int32, \"baz qux\": Float64)" formats "Foo(\"bar\": Int32, \"baz qux\": Float64)" + formats "def foo ( x , y , ) \n end" formats "def foo ( x , y , ) \n end" + formats "foo(bar(baz3 do\nend))" formats "foo(bar(baz3 do\nend))" + formats "<<-HTML\n \#{\"foo\"}\n HTML" formats "<<-HTML\n \#{\"foo\"}\n HTML" + formats "def foo(a,\n **b)\nend" formats "def foo(a,\n **b)\nend" + formats "if 1\nelse\n# nothing\nend" formats "if 1\nelse\n# nothing\nend" + formats "[1, 2, 3, ]" formats "[1, 2, 3, ]" + formats "Hash{\n foo => <<-EOF,\n foo\n EOF\n}" formats "Hash{\n foo => <<-EOF,\n foo\n EOF\n}" + formats "macro foo\n {{1 + 2}}\nend" formats "macro foo\n {{1 + 2}}\nend" + formats "[\n <<-EOF,\n foo\n EOF\n]" formats "[\n <<-EOF,\n foo\n EOF\n]" + formats "foo { |x, *y| }" formats "foo { |x, *y| }" + formats "lib Foo\n fun foo =\n bar : Void\nend" formats "lib Foo\n fun foo =\n bar : Void\nend" + formats "struct Foo(T)\n# bar\n1\nend" formats "struct Foo(T)\n# bar\n1\nend" + formats "def foo\n a = 1; # foo\n a = 2; # bar\nend\n" formats "def foo\n a = 1; # foo\n a = 2; # bar\nend\n" + formats "lib Foo\n fun Bar\nend" formats "lib Foo\n fun Bar\nend" + formats "foo do # a\n # b\n bar\nend" formats "foo do # a\n # b\n bar\nend" + formats "foo do \n x \n end" formats "foo do \n x \n end" + formats "next { {1, 2}, {3, 4} }" formats "next { {1, 2}, {3, 4} }" + formats "'\\n'" formats "'\\n'" + formats "alias A = ({A, (B)})" formats "alias A = ({A, (B)})" + formats "offsetof( String, @length )" formats "offsetof( String, @length )" + formats "foo(1 ||\n # foo\n 2)" formats "foo(1 ||\n # foo\n 2)" + formats "asm(\"nop\" :: \"r\"(0))" formats "asm(\"nop\" :: \"r\"(0))" + formats "begin\n 1\nend\n\n1\n" formats "begin\n 1\nend\n\n1\n" + formats "alias Foo =Bar" formats "alias Foo =Bar" + formats "class X\n annotation FooAnnotation \n end \n end" formats "class X\n annotation FooAnnotation \n end \n end" + formats "foo self // 1" formats "foo self // 1" + formats "long_variable_name = [1, 2, 3, # foo\n 4, 5, 6]" formats "long_variable_name = [1, 2, 3, # foo\n 4, 5, 6]" + formats "NamedTuple()" formats "NamedTuple()" + formats "alias Foo::Bar = Baz" formats "alias Foo::Bar = Baz" + formats "return { {1, 2}, {3, 4} }" formats "return { {1, 2}, {3, 4} }" + formats "\"\#{foo = 1\n}\"" formats "\"\#{foo = 1\n}\"" + formats "case 1 \n when 2 , 3 \n 4 \n end" formats "case 1 \n when 2 , 3 \n 4 \n end" + formats "@[Foo( 1, 2, foo: 3 )]" formats "@[Foo( 1, 2, foo: 3 )]" + formats "def foo(a : T) forall T \n #\nend" formats "def foo(a : T) forall T \n #\nend" + formats ":&" formats ":&" + formats "def foo(&block: Int32)\nend" formats "def foo(&block: Int32)\nend" + formats "if 1\n2\nelsif\n3\n4\nelse\n6\nend" formats "if 1\n2\nelsif\n3\n4\nelse\n6\nend" + formats "lib Foo\nstruct Foo\nend\nend" formats "lib Foo\nstruct Foo\nend\nend" + formats "1 + \n2" formats "1 + \n2" + formats "if 1 # foo\nend" formats "if 1 # foo\nend" + formats "asm(\"a\" : : : : \"volatile\")" formats "asm(\"a\" : : : : \"volatile\")" + formats "foo(out x)" formats "foo(out x)" + formats "{% if z %}\n 1\n{% end %}\n\ndef foo\n z =\n 123 + # foo\n 4 # bar\n\n 1\nend" formats "{% if z %}\n 1\n{% end %}\n\ndef foo\n z =\n 123 + # foo\n 4 # bar\n\n 1\nend" + formats "select\nwhen foo # foo\n # bar\nelse # foo\n # bar\nend" formats "select\nwhen foo # foo\n # bar\nelse # foo\n # bar\nend" + formats "foo . bar()" formats "foo . bar()" + formats "a = 1\na ||= begin\n 1\nend" formats "a = 1\na ||= begin\n 1\nend" + formats "1" formats "1" + formats "x = 1\nx += 1" formats "x = 1\nx += 1" + formats "class Foo\n1\n\n# foo\nend" formats "class Foo\n1\n\n# foo\nend" + formats "foo (1; 2)" formats "foo (1; 2)" + formats "{ %w() }" formats "{ %w() }" + formats "lib Foo\n fun foo =\n\n\n bar(Int32) : Int32\nend" formats "lib Foo\n fun foo =\n\n\n bar(Int32) : Int32\nend" + formats "1&+2&*3" formats "1&+2&*3" + formats "-> :: foo!" formats "-> :: foo!" + formats "while 1 # foo\n # bar\n 2\nend" formats "while 1 # foo\n # bar\n 2\nend" + formats "foo = 1\n->foo.foo=" formats "foo = 1\n->foo.foo=" + formats "/ /" formats "/ /" + formats "foo = {1, {2,\n 3},\n 4}" formats "foo = {1, {2,\n 3},\n 4}" + formats "def foo(a : T) forall T\n #\n\nend" formats "def foo(a : T) forall T\n #\n\nend" + formats "macro foo\n def bar\n {{\n 1 + 2\n }}\n end\nend" formats "macro foo\n def bar\n {{\n 1 + 2\n }}\n end\nend" + formats "begin\n begin\n\n end\nend" formats "begin\n begin\n\n end\nend" + formats "%{hello}" formats "%{hello}" + formats "1 #=>2" formats "1 #=>2" + formats "foo . responds_to?( :bar )" formats "foo . responds_to?( :bar )" + formats "loop do\n 1\nrescue\n 2\nend" formats "loop do\n 1\nrescue\n 2\nend" + formats "asm(\"a\" : \"b\"(1), \"c\"(2) : \"d\"(3) : : \"volatile\")" formats "asm(\"a\" : \"b\"(1), \"c\"(2) : \"d\"(3) : : \"volatile\")" + formats "case 1 # foo\nwhen 2 then 3 # bar\nwhen 4 then 5 # baz\nelse 6 # zzz\nend" formats "case 1 # foo\nwhen 2 then 3 # bar\nwhen 4 then 5 # baz\nelse 6 # zzz\nend" + formats "case 1 \n when 2 \n 3 \n end" formats "case 1 \n when 2 \n 3 \n end" + formats "begin\n1\nensure\n2\nend" formats "begin\n1\nensure\n2\nend" + formats "foo(1 &- 2)" formats "foo(1 &- 2)" + formats "break *1" formats "break *1" + formats "until 1\n2\nend" formats "until 1\n2\nend" + formats "foo(1, ) do\nend" formats "foo(1, ) do\nend" + formats "foo = 1\n->foo.bar(Int32*)" formats "foo = 1\n->foo.bar(Int32*)" + formats "foo[x: 1, &.bar] ||= 1" formats "foo[x: 1, &.bar] ||= 1" + formats "-> :: Foo . foo=" formats "-> :: Foo . foo=" + formats "->@@foo.foo?" formats "->@@foo.foo?" + formats "foo . responds_to? :bar" formats "foo . responds_to? :bar" + formats "foo(bar([\n 1,\n]))" formats "foo(bar([\n 1,\n]))" + formats "foo do # hello\nend" formats "foo do # hello\nend" + formats "class Foo\nx = 1\nend" formats "class Foo\nx = 1\nend" + formats "Foo::Bar(T, U?)?" formats "Foo::Bar(T, U?)?" + formats "alias A = (B)" formats "alias A = (B)" + formats "1.>= do\nend" formats "1.>= do\nend" Crystal::Repl::Interpreter types - interprets crystal_type_id for virtual metaclass type (#12228) interprets crystal_type_id for virtual metaclass type (#12228) does class method on virtual metaclass casted to generic metaclass (#12302) does class method on virtual metaclass casted to generic metaclass (#12302) + discards .class discards .class + discards Path discards Path interprets path to type interprets path to type + interprets class for virtual_type type (struct) interprets class for virtual_type type (struct) + discards typeof discards typeof interprets class_crystal_instance_type_id interprets class_crystal_instance_type_id - interprets class for non-union type interprets class for non-union type discards class for virtual_type type discards class for virtual_type type - discards crystal_type_id discards crystal_type_id - interprets class for virtual_type type (struct) interprets class for virtual_type type (struct) - interprets crystal_type_id for nil interprets crystal_type_id for nil discards class for non-union type discards class for non-union type - discards .class discards .class - discards typeof discards typeof - discards Path discards Path discards generic discards generic + discards crystal_type_id discards crystal_type_id + interprets class for non-union type interprets class for non-union type + interprets crystal_type_id for nil interprets crystal_type_id for nil interprets crystal_type_id for non-nil interprets crystal_type_id for non-nil interprets class for module type (#12203) interprets class for module type (#12203) + interprets crystal_type_id for virtual metaclass type (#12228) interprets crystal_type_id for virtual metaclass type (#12228) interprets class for virtual_type type interprets class for virtual_type type -Code gen: asm - codegens with two inputs codegens with two inputs - codegens with two outputs codegens with two outputs - codegens without inputs codegens without inputs - codegens with intel dialect codegens with intel dialect - codegens with one input codegens with one input - passes correct string length to LLVM passes correct string length to LLVM -Semantic: c enum - types enum value with base type types enum value with base type - types enum value types enum value - errors if enum base type is not an integer errors if enum base type is not an integer - allows using an enum as a type in a struct allows using an enum as a type in a struct - errors if enum value is different from default (Int32) (#194) errors if enum value is different from default (Int32) (#194) - allows using an enum as a type in a fun allows using an enum as a type in a fun -Semantic: new - evaluates initialize default value at the instance scope (4) (#731) evaluates initialize default value at the instance scope (4) (#731) - inherits initialize and new methods if doesn't define new (#3238) inherits initialize and new methods if doesn't define new (#3238) - errors if using self call in default argument (2) errors if using self call in default argument (2) - evaluates initialize default value at the instance scope (6) (#731) evaluates initialize default value at the instance scope (6) (#731) - errors if using self call in default argument (3) errors if using self call in default argument (3) - evaluates initialize default value at the instance scope (2) (#731) evaluates initialize default value at the instance scope (2) (#731) - errors if using self call in default argument (1) errors if using self call in default argument (1) - doesn't have default new for inherited class from generic type doesn't have default new for inherited class from generic type - uses correct receiver for `initialize` in namespaced generic classes (#4086) uses correct receiver for `initialize` in namespaced generic classes (#4086) - evaluates initialize default value at the instance scope (3) (#731) evaluates initialize default value at the instance scope (3) (#731) - doesn't incorrectly redefines new for generic class doesn't incorrectly redefines new for generic class - evaluates initialize default value at the instance scope (1) (#731) evaluates initialize default value at the instance scope (1) (#731) - evaluates initialize default value at the instance scope (5) (#731) evaluates initialize default value at the instance scope (5) (#731) -Code gen: experimental - errors if missing link arguments errors if missing link arguments - errors if too many arguments errors if too many arguments - compiles with single string argument compiles with single string argument - errors if invalid argument type errors if invalid argument type - compiles with no argument compiles with no argument -Semantic: offsetof - errors on undefined instance variable errors on undefined instance variable - can be used with generic types can be used with generic types - gives error if using offsetof on something that's neither a class, a struct nor a Tuple gives error if using offsetof on something that's neither a class, a struct nor a Tuple - gives error if using offsetof on non-Tuples with an index gives error if using offsetof on non-Tuples with an index - gives error if using offsetof on Tuples with indexes greater than tuple size gives error if using offsetof on Tuples with indexes greater than tuple size - gives error if using offsetof on Tuples with negative indexes gives error if using offsetof on Tuples with negative indexes - types offsetof types offsetof - errors on typeof inside offsetof expression errors on typeof inside offsetof expression - can be used with classes can be used with classes - gives error if using offsetof on Tuples with instance variables gives error if using offsetof on Tuples with instance variables - errors on offsetof element of uninstantiated generic type errors on offsetof element of uninstantiated generic type - gives error if using offsetof on something that can't have instance variables gives error if using offsetof on something that can't have instance variables -Normalize: string interpolation - replaces through multiple levels replaces through multiple levels - replaces string constant replaces string constant - normalizes heredoc normalizes heredoc - normalizes string interpolation normalizes string interpolation - replaces string constant that results from macro expansion replaces string constant that results from macro expansion - normalizes string interpolation with multiple lines normalizes string interpolation with multiple lines -Code gen: next - codegens next conditionally with int type (2) codegens next conditionally with int type (2) - codegens next codegens next - codegens next with while inside block codegens next with while inside block - codegens next with break (1) codegens next with break (1) - codegens next with break (2) codegens next with break (2) - codegens next without expressions codegens next without expressions - codegens next conditionally codegens next conditionally - codegens next with break (3) codegens next with break (3) -Semantic: special vars - types $? when not defined as no return (2) types $? when not defined as no return (2) - types $~ when not defined as no return types $~ when not defined as no return - infers in block infers in block - types $~ when not defined as no return (2) types $~ when not defined as no return (2) - infers after block infers after block - infers in block with nested block infers in block with nested block - infers when assigning inside block infers when assigning inside block - errors if assigning $? at top level errors if assigning $? at top level - types $? when not defined as no return types $? when not defined as no return - errors if assigning $~ at top level errors if assigning $~ at top level - infers $~ infers $~ - infers $? infers $? -Normalize: def - expands def with reserved external name (#6559) expands def with reserved external name (#6559) - expands a def on request with default arguments and type restrictions expands a def on request with default arguments and type restrictions - expands with magic constant specifying one when not all are magic expands with magic constant specifying one when not all are magic - expands with magic constant with named arg expands with magic constant with named arg - expands with two named argument and one not expands with two named argument and one not - expands with more named arg which come in the correct order expands with more named arg which come in the correct order - expands a def with external names (1) expands a def with external names (1) - expands a def on request with default arguments that yields (external names) expands a def on request with default arguments that yields (external names) - expands a def with splat and double splat expands a def with splat and double splat - expands a def with double splat and two named args and regular args expands a def with double splat and two named args and regular args - expands with magic constant specifying one when all are magic expands with magic constant specifying one when all are magic - expands with one named arg that is the only one (2) expands with one named arg that is the only one (2) - expands a def on request with default arguments that yields (2) expands a def on request with default arguments that yields (2) - expands a def on request with default arguments (2) expands a def on request with default arguments (2) - expands a def on request with default arguments and type restrictions (2) expands a def on request with default arguments and type restrictions (2) - expands a def on request with default arguments (external names) expands a def on request with default arguments (external names) - expands with splat and default argument expands with splat and default argument - expands a def with double splat and no args expands a def with double splat and no args - expands with splat and zero expands with splat and zero - expands arg with default value after splat expands arg with default value after splat - expands with one named arg that is the only one (1) expands with one named arg that is the only one (1) - expands a def with external names (2) expands a def with external names (2) - expands a def on request with default arguments expands a def on request with default arguments - expands with splat with one arg before expands with splat with one arg before - expands with named argument and yield expands with named argument and yield - expands a new def with double splat and two named args and regular args expands a new def with double splat and two named args and regular args - expands with magic constant expands with magic constant - expands a def on request with default arguments that yields expands a def on request with default arguments that yields - expands a def with double splat and two named args expands a def with double splat and two named args - expands with named argument expands with named argument - expands with splat expands with splat - expands with two named argument expands with two named argument - uses bare * uses bare * - gives correct body location with - block instance var arg, without body block instance var arg, without body - splat arg, with body splat arg, with body - default arg with restriction, without body default arg with restriction, without body - default arg, with body default arg, with body - block instance var arg, with body block instance var arg, with body - splat arg, without body splat arg, without body - default arg, without body default arg, without body - default arg with restriction, with body default arg with restriction, with body - expands with magic constant with named arg with yield expands with magic constant with named arg with yield - expands default value after splat index expands default value after splat index -Semantic: while - types endless while with break with value types endless while with break with value - types endless while with multiple breaks with value types endless while with multiple breaks with value - finds all while cond assign targets in expressions (6) finds all while cond assign targets in expressions (6) - restricts type after `while` with `not` and `and` (#4242) restricts type after `while` with `not` and `and` (#4242) - types while with break without value types while with break without value - types while with assignment and && types while with assignment and && - uses var type inside while if endless loop uses var type inside while if endless loop - types while types while - finds while cond assign target in Not (#10345) finds while cond assign target in Not (#10345) - doesn't use type at end of endless while if variable is reassigned (2) doesn't use type at end of endless while if variable is reassigned (2) - types while with break with value types while with break with value - doesn't fail on Expressions condition (2) doesn't fail on Expressions condition (2) - doesn't use type at end of endless while if variable is reassigned (3) doesn't use type at end of endless while if variable is reassigned (3) - uses type at end of endless while if variable is reassigned, but not before first break uses type at end of endless while if variable is reassigned, but not before first break - types while with multiple breaks with value types while with multiple breaks with value - uses var type inside while if endless loop (2) uses var type inside while if endless loop (2) - types variable as nilable if raise before assign types variable as nilable if raise before assign - doesn't type var as nilable after break inside rescue doesn't type var as nilable after break inside rescue - restricts type after while (#4242) restricts type after while (#4242) - doesn't fail on nested conditionals inside typeof condition doesn't fail on nested conditionals inside typeof condition - reports next cannot be used outside a while reports next cannot be used outside a while - marks variable as nil if breaking before assigning to it in an endless loop marks variable as nil if breaking before assigning to it in an endless loop - doesn't fail on Expressions condition (1) doesn't fail on Expressions condition (1) - types while with && (#1425) types while with && (#1425) - finds all while cond assign targets in expressions (4) finds all while cond assign targets in expressions (4) - types endless while with break without value types endless while with break without value - restricts type after while with not (#4242) restricts type after while with not (#4242) - doesn't fail on new variables inside typeof condition doesn't fail on new variables inside typeof condition - doesn't modify var's type before while doesn't modify var's type before while - types while with assignment types while with assignment - marks variable as nil if breaking before assigning to it in an endless loop (2) marks variable as nil if breaking before assigning to it in an endless loop (2) - types while true as NoReturn types while true as NoReturn - types while (true) as NoReturn types while (true) as NoReturn - reports break cannot be used outside a while reports break cannot be used outside a while - finds all while cond assign targets in expressions (5) finds all while cond assign targets in expressions (5) - finds all while cond assign targets in expressions (3) finds all while cond assign targets in expressions (3) - types while with assignment and call types while with assignment and call - finds all while cond assign targets in expressions (#10350) finds all while cond assign targets in expressions (#10350) - finds all while cond assign targets in expressions (2) finds all while cond assign targets in expressions (2) - doesn't restrict type after while if there's a break (#4242) doesn't restrict type after while if there's a break (#4242) - doesn't use type at end of endless while if variable is reassigned doesn't use type at end of endless while if variable is reassigned - uses type at end of endless while if variable is reassigned, but not before first break (2) uses type at end of endless while if variable is reassigned, but not before first break (2) - rebinds condition variable after while body (#6158) rebinds condition variable after while body (#6158) - types while ((true)) as NoReturn types while ((true)) as NoReturn -Crystal::Repl::Interpreter - calls - inlines call that returns self inlines call that returns self - mutates through pointer (1) mutates through pointer (1) - mutates through inlined instance var without receiver mutates through inlined instance var without receiver - does call on var that's a struct, takes a pointer to instance var, inside if does call on var that's a struct, takes a pointer to instance var, inside if - does call on constant that's a struct, takes a pointer to instance var, inside if does call on constant that's a struct, takes a pointer to instance var, inside if - calls a top-level method with two arguments calls a top-level method with two arguments - inlines method that just reads an instance var, but produces side effects of args inlines method that just reads an instance var, but produces side effects of args - does Assign class var with wants_struct_pointer does Assign class var with wants_struct_pointer - mutates call argument mutates call argument - does call on ivar that's a struct, takes a pointer to instance var, inside if does call on ivar that's a struct, takes a pointer to instance var, inside if - does call on constant that's a struct, takes a pointer to instance var does call on constant that's a struct, takes a pointer to instance var - does call on instance var that's a struct, from a class does call on instance var that's a struct, from a class - does ReadInstanceVar with wants_struct_pointer does ReadInstanceVar with wants_struct_pointer - calls a top-level method without arguments but with local vars calls a top-level method without arguments but with local vars - interprets implicit self call for pointer interprets implicit self call for pointer - mutates through pointer (3) mutates through pointer (3) - interprets explicit self call for primitive types interprets explicit self call for primitive types - discards call with struct as obj discards call with struct as obj - does call on instance var that's a struct, from a struct does call on instance var that's a struct, from a struct - calls a top-level method without arguments and no local vars calls a top-level method without arguments and no local vars - mutates through pointer (2) mutates through pointer (2) - does call on read instance var that's a struct, takes a pointer to instance var does call on read instance var that's a struct, takes a pointer to instance var - interprets call with if interprets call with if - does call with struct as obj does call with struct as obj - mutates through read instance var mutates through read instance var - interprets call with default values interprets call with default values - puts struct pointer after tuple indexer puts struct pointer after tuple indexer - does Assign var with wants_struct_pointer does Assign var with wants_struct_pointer - does call on self that's a struct, takes a pointer to instance var, inside if does call on self that's a struct, takes a pointer to instance var, inside if - does call with struct as obj (2) does call with struct as obj (2) - inlines call that returns self (2) inlines call that returns self (2) - inlines method that just reads an instance var (2) inlines method that just reads an instance var (2) - interprets self for primitive types interprets self for primitive types - inlines method that just reads an instance var inlines method that just reads an instance var - does Assign instance var with wants_struct_pointer does Assign instance var with wants_struct_pointer - does call on Pointer#value that's a struct, takes a pointer to instance var does call on Pointer#value that's a struct, takes a pointer to instance var - mutates through inlined instance var with receiver mutates through inlined instance var with receiver - interprets call with named arguments interprets call with named arguments -Code gen: new - codegens instance method with allocate codegens instance method with allocate - evaluates initialize default value at the instance scope (3) (#731) evaluates initialize default value at the instance scope (3) (#731) - can create Reference can create Reference - codegens instance method with new and instance var codegens instance method with new and instance var - overloads new and initialize, 1 (#2489) overloads new and initialize, 1 (#2489) - can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new can create Tuple with Tuple.new - inherits initialize inherits initialize - evaluates initialize default value at the instance scope (4) (#731) evaluates initialize default value at the instance scope (4) (#731) - inherits initialize for generic type inherits initialize for generic type - evaluates initialize default value at the instance scope (1) (#731) evaluates initialize default value at the instance scope (1) (#731) - codegens instance method with new codegens instance method with new - finds new in superclass if no initialize is defined (2) finds new in superclass if no initialize is defined (2) - overloads new and initialize, 3 (#2489) overloads new and initialize, 3 (#2489) - finds super in deep hierarchy finds super in deep hierarchy - finds new in superclass if no initialize is defined (1) finds new in superclass if no initialize is defined (1) - evaluates initialize default value at the instance scope (2) (#731) evaluates initialize default value at the instance scope (2) (#731) - defines new for module defines new for module - overloads new and initialize, 2 (#2489) overloads new and initialize, 2 (#2489) - finds new in superclass for Enum finds new in superclass for Enum -Normalize: multi assign - normalizes m to n, with *_ on left-hand side (3) normalizes m to n, with *_ on left-hand side (3) - normalizes n to splat on left-hand side normalizes n to splat on left-hand side - normalizes 1 to n, with *_ on left-hand side (3) normalizes 1 to n, with *_ on left-hand side (3) - normalizes m to n, with splat on left-hand side, splat is non-empty normalizes m to n, with splat on left-hand side, splat is non-empty - normalizes n to n normalizes n to n - normalizes m to n, with splat on left-hand side, splat is empty normalizes m to n, with splat on left-hand side, splat is empty - strict_multi_assign - normalizes 1 to n with [] normalizes 1 to n with [] - normalizes 1 to n with call normalizes 1 to n with call - normalizes 1 to n normalizes 1 to n - normalizes m to n, with *_ on left-hand side (2) normalizes m to n, with *_ on left-hand side (2) - normalizes 1 to n, with *_ on left-hand side (1) normalizes 1 to n, with *_ on left-hand side (1) - normalizes m to n, with *_ on left-hand side (1) normalizes m to n, with *_ on left-hand side (1) - normalizes n to n with [] normalizes n to n with [] - normalizes n to n with call normalizes n to n with call - without strict_multi_assign - normalizes 1 to n with [] normalizes 1 to n with [] - normalizes 1 to n normalizes 1 to n - normalizes 1 to n with call normalizes 1 to n with call - normalizes 1 to splat on left-hand side normalizes 1 to splat on left-hand side - normalizes 1 to *_ on left-hand side normalizes 1 to *_ on left-hand side - normalizes 1 to n, with splat on left-hand side, splat before other targets normalizes 1 to n, with splat on left-hand side, splat before other targets - normalizes 1 to n, with splat on left-hand side normalizes 1 to n, with splat on left-hand side - normalizes 1 to n, with splat on left-hand side, splat after other targets normalizes 1 to n, with splat on left-hand side, splat after other targets - normalizes 1 to n, with *_ on left-hand side (2) normalizes 1 to n, with *_ on left-hand side (2) - normalizes n to *_ on left-hand side normalizes n to *_ on left-hand side -Semantic: primitives - types 1 + 2 types 1 + 2 - types @[Primitive] method types @[Primitive] method - Slice.literal - with element type - types empty literal types empty literal - errors if element type is not primitive int or float errors if element type is not primitive int or float - errors if element is not number literal errors if element is not number literal - types primitive int literal types primitive int literal - errors if element is out of range errors if element is out of range - types primitive float literal types primitive float literal - types a float32 types a float32 - errors if @[Primitive] has no args errors if @[Primitive] has no args - errors if using instance variable inside primitive type errors if using instance variable inside primitive type - extends from Number and doesn't find + method extends from Number and doesn't find + method - correctly types first hash from type vars (bug) correctly types first hash from type vars (bug) - allows @[Primitive] on method that has body allows @[Primitive] on method that has body - types nil types nil - types an int32 types an int32 - types an expression types an expression - types char ord types char ord - extends from Number and doesn't find >= method extends from Number and doesn't find >= method - computes correct hash value type if it's a function literal (#320) computes correct hash value type if it's a function literal (#320) - extends from Number and doesn't find to_i method extends from Number and doesn't find to_i method - types nop types nop - types a symbol types a symbol - can invoke binary on primitive typedef (2) (#614) can invoke binary on primitive typedef (2) (#614) - can invoke binary on primitive typedef (#614) can invoke binary on primitive typedef (#614) - types pointer of int types pointer of int - types a char types a char - types va_arg primitive types va_arg primitive - types a string types a string - Reference.pre_initialize - errors on abstract type errors on abstract type - types with virtual reference type types with virtual reference type - types with reference type types with reference type - errors on uninstantiated generic type errors on uninstantiated generic type - looks up return type in correct scope (#13652) looks up return type in correct scope (#13652) - errors when comparing void (#225) errors when comparing void (#225) - types a int128 types a int128 - types a uint128 types a uint128 - types a int64 types a int64 - can invoke cast on primitive typedef (#614) can invoke cast on primitive typedef (#614) - types a bool types a bool - errors if @[Primitive] has non-symbol arg errors if @[Primitive] has non-symbol arg - types a float64 types a float64 +Code gen: c enum + codegens enum with 10 // 2 codegens enum with 10 // 2 + codegens enum with 3 &* 2 codegens enum with 3 &* 2 + codegens enum with ~1 codegens enum with ~1 + codegens enum that refers to another enum constant codegens enum that refers to another enum constant + codegens enum value codegens enum value + codegens enum with -1 codegens enum with -1 + codegens enum that refers to another constant codegens enum that refers to another constant + codegens enum with 10 ^ 3 codegens enum with 10 ^ 3 + codegens enum with +1 codegens enum with +1 + codegens enum value 3 codegens enum value 3 + codegens enum with (1 + 2) * 3 codegens enum with (1 + 2) * 3 + codegens enum with 3 &- 2 codegens enum with 3 &- 2 + codegens enum with 100 >> 3 codegens enum with 100 >> 3 + codegens enum with 10 | 3 codegens enum with 10 | 3 + codegens enum value 4 codegens enum value 4 + codegens enum with 3 - 2 codegens enum with 3 - 2 + codegens enum value 2 codegens enum value 2 + codegens enum with 3 * 2 codegens enum with 3 * 2 + codegens enum with 1 + 2 codegens enum with 1 + 2 + codegens enum with 1 &+ 2 codegens enum with 1 &+ 2 + codegens enum with 1 << 3 codegens enum with 1 << 3 + codegens enum with 10 & 3 codegens enum with 10 & 3 + codegens enum with 10 % 3 codegens enum with 10 % 3 +Lexer macro + lexes macro with embedded string with %[ lexes macro with embedded string with %[ + lexes macro var lexes macro var + lexes macro with nested macro lexes macro with nested macro + lexes macro with nested embedded string with %( lexes macro with nested embedded string with %( + lexes macro with embedded char and sharp lexes macro with embedded char and sharp + lexes macro with semicolon before end lexes macro with semicolon before end + lexes macro with curly escape lexes macro with curly escape + lexes begin end lexes begin end + lexes macro with embedded string with %< ignores begin lexes macro with embedded string with %< ignores begin + lexes with for inside escaped macro (#1029) lexes with for inside escaped macro (#1029) + lexes macro with embedded string lexes macro with embedded string + lexes macro with string interpolation and double curly brace lexes macro with string interpolation and double curly brace + lexes macro with nested annotation lexes macro with nested annotation + lexes macro with nested struct lexes macro with nested struct + reaches end reaches end + lexes macro with comments lexes macro with comments + doesn't lex macro var if escaped doesn't lex macro var if escaped + lexes with if/end inside escaped macro (#1029) lexes with if/end inside escaped macro (#1029) + lexes macro with embedded string with %[ ignores begin lexes macro with embedded string with %[ ignores begin + lexes macro with nested def lexes macro with nested def + lexes bug #654 lexes bug #654 + lexes macro with nested class lexes macro with nested class + lexes macro with nested while lexes macro with nested while + lexes macro with curly escape in comment lexes macro with curly escape in comment + lexes macro with embedded string and expression lexes macro with embedded string and expression + lexes macro with if as suffix after return lexes macro with if as suffix after return + lexes macro with nested abstract struct lexes macro with nested abstract struct + lexes macro without nested if lexes macro without nested if + lexes macro with embedded string and backslash lexes macro with embedded string and backslash + keeps correct line number after lexes the part of keyword and newline (#4656) keeps correct line number after lexes the part of keyword and newline (#4656) + lexes macro with nested abstract class lexes macro with nested abstract class + lexes macro with nested begin lexes macro with nested begin + skips whitespace skips whitespace + lexes macro with slash not followed by curly lexes macro with slash not followed by curly + lexes macro with if as suffix lexes macro with if as suffix + lexes macro with expression lexes macro with expression + lexes macro with nested lib lexes macro with nested lib + lexes macro with nested case lexes macro with nested case + lexes macro with comments and expressions lexes macro with comments and expressions + lexes macro with nested abstract def lexes macro with nested abstract def + lexes macro with nested union lexes macro with nested union + lexes macro with embedded string with %( ignores begin lexes macro with embedded string with %( ignores begin + lexes macro with nested do lexes macro with nested do + lexes macro with embedded string with %< lexes macro with embedded string with %< + lexes macro with embedded string with %( lexes macro with embedded string with %( + lexes macro with nested module lexes macro with nested module + keeps correct column and line numbers keeps correct column and line numbers + lexes macro with nested select lexes macro with nested select + lexes macro with if after assign lexes macro with if after assign + lexes macro with nested enum lexes macro with nested enum + lexes macro with nested fun lexes macro with nested fun + lexes macro with control lexes macro with control + lexes with unless inside escaped macro (#5664) lexes with unless inside escaped macro (#5664) + lexes macro with nested if lexes macro with nested if + lexes simple macro lexes simple macro + lexes macro with nested until lexes macro with nested until + lexes macro with nested unless lexes macro with nested unless + lexes escaped quote inside string (#895) lexes escaped quote inside string (#895) Parser doc - includes doc for fun def includes doc for fun def - includes doc for abstract class includes doc for abstract class - includes doc for class includes doc for class + includes doc for macro includes doc for macro + disables doc parsing inside defs disables doc parsing inside defs includes doc for def includes doc for def - includes doc for constant assign includes doc for constant assign - includes doc for alias includes doc for alias + includes doc for class includes doc for class includes doc for call without obj includes doc for call without obj - disables doc parsing inside defs disables doc parsing inside defs + includes doc for struct includes doc for struct + includes doc for constant assign includes doc for constant assign + includes doc for abstract class includes doc for abstract class + includes doc for fun def includes doc for fun def includes doc for module includes doc for module - includes doc for abstract def includes doc for abstract def - includes doc for private def includes doc for private def + includes doc for alias includes doc for alias includes doc for enum def includes doc for enum def - includes doc for struct includes doc for struct includes doc for annotation includes doc for annotation - includes doc for macro includes doc for macro -Semantic: class - allows using self in class scope allows using self in class scope - says wrong number of arguments for abstract class new says wrong number of arguments for abstract class new - uses number type var in class method uses number type var in class method - inherits self twice (#5495) inherits self twice (#5495) - errors if using underscore in generic class errors if using underscore in generic class - errors if declares class inside if errors if declares class inside if - doesn't mark instance variable as nilable if calling another initialize doesn't mark instance variable as nilable if calling another initialize - errors if reopening generic class with different splat index (2) errors if reopening generic class with different splat index (2) - doesn't error on new on abstract virtual type class doesn't error on new on abstract virtual type class - preserves order of instance vars (#3050) preserves order of instance vars (#3050) - allows defining classes inside modules or classes with :: allows defining classes inside modules or classes with :: - allows declaring a variable in an initialize and using it allows declaring a variable in an initialize and using it - errors if reopening generic class with different splat index (3) errors if reopening generic class with different splat index (3) - doesn't lookup new in supermetaclass doesn't lookup new in supermetaclass - can use short name for top-level type can use short name for top-level type - errors if inherits from metaclass errors if inherits from metaclass - types instance variable on getter types instance variable on getter - can invoke method on abstract generic type with subclasses but no instances can invoke method on abstract generic type with subclasses but no instances - can't reopen as module can't reopen as module - types recursive type types recursive type - errors if reopening non-generic class as generic errors if reopening non-generic class as generic - doesn't crash on instance variable assigned a proc, and never instantiated (#923) doesn't crash on instance variable assigned a proc, and never instantiated (#923) - reads an object instance var reads an object instance var - types type var union types type var union - types Const#new types Const#new - can mark initialize as private can mark initialize as private - does automatic type inference of new for generic types 2 does automatic type inference of new for generic types 2 - correctly types #680 correctly types #680 - infers generic type after instance was created with explicit type infers generic type after instance was created with explicit type - finds in global scope if includes module finds in global scope if includes module - can't use implicit initialize if defined in parent can't use implicit initialize if defined in parent - errors if reopening generic class with different type vars (2) errors if reopening generic class with different type vars (2) - can invoke method on abstract generic type without subclasses nor instances can invoke method on abstract generic type without subclasses nor instances - reads an object instance var from a union type reads an object instance var from a union type - types instance variable types instance variable - errors if reading ivar from non-ivar container errors if reading ivar from non-ivar container - types Const#new#method types Const#new#method - doesn't use initialize from base class doesn't use initialize from base class - errors if creating instance before typing instance variable errors if creating instance before typing instance variable - does automatic inference of new for generic types does automatic inference of new for generic types - errors when wrong arguments for new errors when wrong arguments for new - reports can't instantiate abstract class on allocate reports can't instantiate abstract class on allocate - errors when creating Value errors when creating Value - says wrong number of arguments for abstract class new (2) says wrong number of arguments for abstract class new (2) - can invoke method on abstract type without subclasses nor instances can invoke method on abstract type without subclasses nor instances - types as no return if calling method on abstract class with generic subclasses but no instances (#6996) types as no return if calling method on abstract class with generic subclasses but no instances (#6996) - types virtual method of generic class types virtual method of generic class - can't reopen as struct can't reopen as struct - errors on no method found on abstract class, class method (#2241) errors on no method found on abstract class, class method (#2241) - types Const#allocate types Const#allocate - types as no return if calling method on generic class with subclasses (#6996) types as no return if calling method on generic class with subclasses (#6996) - errors if reading non-existent ivar errors if reading non-existent ivar - does automatic type inference of new for nested generic type does automatic type inference of new for nested generic type - uses self as type var uses self as type var - allows instantiating generic class with number allows instantiating generic class with number - reports uninitialized constant reports uninitialized constant - reports undefined instance method reports undefined instance method - reads a virtual type instance var reads a virtual type instance var - errors if reopening generic class with different splat index errors if reopening generic class with different splat index - doesn't use initialize from base class with virtual type doesn't use initialize from base class with virtual type - says that instance vars are not allowed in metaclass says that instance vars are not allowed in metaclass - types as no return if calling method on abstract class with all abstract subclasses (#6996) types as no return if calling method on abstract class with all abstract subclasses (#6996) - types class and subclass as one type types class and subclass as one type - correctly types #680 (2) correctly types #680 (2) - types self inside method call without obj types self inside method call without obj - errors if reopening generic class with different type vars errors if reopening generic class with different type vars - types generic of generic type types generic of generic type - errors if inheriting Gen(self) and there's no self (#2890) errors if inheriting Gen(self) and there's no self (#2890) - doesn't mix classes on definition (#2352) doesn't mix classes on definition (#2352) - types class and subclass as one type types class and subclass as one type - types bug #168 (it inherits instance var even if not mentioned in initialize) types bug #168 (it inherits instance var even if not mentioned in initialize) - types as no return if calling method on abstract generic class (#6996) types as no return if calling method on abstract generic class (#6996) - doesn't crash with top-level initialize (#2601) doesn't crash with top-level initialize (#2601) - reports wrong number of arguments for initialize reports wrong number of arguments for initialize - types instance variable types instance variable - doesn't lookup type in parents' namespaces, and lookups and in program doesn't lookup type in parents' namespaces, and lookups and in program - types class and subclass as one type types class and subclass as one type - uses self as type var uses self as type var - errors if inherits from module errors if inherits from module - inherits self (#2890) inherits self (#2890) - inherits Gen(self) (#2890) inherits Gen(self) (#2890) - types class inside class types class inside class - reports undefined method when method inside a class reports undefined method when method inside a class - reports superclass mismatch reports superclass mismatch - reports can't instantiate abstract class on new reports can't instantiate abstract class on new - errors when creating Number errors when creating Number - says no overload matches for class new says no overload matches for class new - hoists instance variable initializer hoists instance variable initializer - errors if assigning superclass to declared instance var errors if assigning superclass to declared instance var - type def does not reopen type from parent namespace (#11181) type def does not reopen type from parent namespace (#11181) - errors if using read-instance-var with non-typed variable errors if using read-instance-var with non-typed variable - reports unknown class when extending reports unknown class when extending + includes doc for abstract def includes doc for abstract def + includes doc for private def includes doc for private def +Semantic: splat + overloads with type restriction and splat (7) overloads with type restriction and splat (7) + uses splat restriction with concrete type uses splat restriction with concrete type + matches with type var splat inside explicit Union, when one splat fails entirely matches with type var splat inside explicit Union, when one splat fails entirely + matches with type var splat inside explicit Union, when all splat elements match matches with type var splat inside explicit Union, when all splat elements match + overloads with splat against method with two arguments (#986) (2) overloads with splat against method with two arguments (#986) (2) + matches type splat with splat in generic type (2) matches type splat with splat in generic type (2) + works if matches splat with type restriction works if matches splat with type restriction + overloads with type restriction and splat (3) overloads with type restriction and splat (3) + splats splats + gives correct error when forwarding splat (2) gives correct error when forwarding splat (2) + errors with too few non-splat type arguments (2) errors with too few non-splat type arguments (2) + overloads with type restriction and splat (2) overloads with type restriction and splat (2) + says missing argument because positional args don't match past splat says missing argument because positional args don't match past splat + errors with too few non-splat type arguments (1) errors with too few non-splat type arguments (1) + Crystal::Splat + with splat with splat + without splat without splat + accesses T when empty, via module accesses T when empty, via module + doesn't shift a call's location doesn't shift a call's location + matches with tuple splat inside explicit Union matches with tuple splat inside explicit Union + calls super with implicit splat arg (#1001) calls super with implicit splat arg (#1001) + matches with type var splat inside explicit Union (2) matches with type var splat inside explicit Union (2) + overloads with type restriction and splat (5) overloads with type restriction and splat (5) + method with splat and optional named argument matches zero args call (#2746) method with splat and optional named argument matches zero args call (#2746) + errors with too many non-splat type arguments errors with too many non-splat type arguments + uses splat restriction after non-splat arguments (#5037) uses splat restriction after non-splat arguments (#5037) + matches type splat with splat in generic type (1) matches type splat with splat in generic type (1) + forwards tuple with an extra argument forwards tuple with an extra argument + overloads with type restriction and splat (4) overloads with type restriction and splat (4) + uses bare * uses bare * + matches with type var and splat of itself inside explicit Union matches with type var and splat of itself inside explicit Union + errors if using two splat indices on restriction errors if using two splat indices on restriction + splats arg and splat against splat (1) (#1042) splats arg and splat against splat (1) (#1042) + matches with splat matches with splat + matches with type var and splat of itself inside explicit Union (2) matches with type var and splat of itself inside explicit Union (2) + uses splat restriction, matches empty uses splat restriction, matches empty + says no overload matches on type restrictions past the splat arg says no overload matches on type restrictions past the splat arg + uses bare *, doesn't let more args uses bare *, doesn't let more args + uses splat restriction uses splat restriction + errors if doesn't match splat with type restriction errors if doesn't match splat with type restriction + overloads with type restriction and splat (6) overloads with type restriction and splat (6) + redefines method with splat (bug #248) redefines method with splat (bug #248) + gives correct error when forwarding splat gives correct error when forwarding splat + matches with type var splat inside explicit Union matches with type var splat inside explicit Union + errors if splatting non-tuple type in return values errors if splatting non-tuple type in return values + errors on zero args with named arg and splat errors on zero args with named arg and splat + allows default value after splat index allows default value after splat index + forwards tuple in return statement forwards tuple in return statement + matches with type var splat inside explicit Union, when non-splat vars fail matches with type var splat inside explicit Union, when non-splat vars fail + doesn't match splat in generic type with unsplatted tuple (#10164) doesn't match splat in generic type with unsplatted tuple (#10164) + matches with type var and splat of itself inside explicit Union (3) matches with type var and splat of itself inside explicit Union (3) + overloads with type restriction and splat (1) overloads with type restriction and splat (1) + matches instantiated generic with splat in generic type matches instantiated generic with splat in generic type + errors if doesn't match splat with type restriction because of zero arguments errors if doesn't match splat with type restriction because of zero arguments + can splat after type filter left it as a tuple (#442) can splat after type filter left it as a tuple (#442) + doesn't crash on non-match (#2521) doesn't crash on non-match (#2521) + splats arg and splat against splat (2) (#1042) splats arg and splat against splat (2) (#1042) + errors if splatting union errors if splatting union + matches partially instantiated generic with splat in generic type matches partially instantiated generic with splat in generic type + doesn't match free var type splats inside explicit Union doesn't match free var type splats inside explicit Union + errors if splatting non-tuple type in call arguments errors if splatting non-tuple type in call arguments + overloads with splat against method with two arguments (#986) (1) overloads with splat against method with two arguments (#986) (1) + method with default arguments and splat matches call with one arg (#2766) method with default arguments and splat matches call with one arg (#2766) +Semantic: yield with scope + infer type of block body infer type of block body + uses method of enclosing scope uses method of enclosing scope + infer type of block body with yield scope and arguments infer type of block body with yield scope and arguments + finds macro finds macro + errors if using instance variable at top level errors if using instance variable at top level + mentions with yield scope and current scope in error mentions with yield scope and current scope in error + passes #229 passes #229 + infer type of empty block body infer type of empty block body + invokes nested calls invokes nested calls + uses instance variable of enclosing scope uses instance variable of enclosing scope + infer type of block body with yield scope infer type of block body with yield scope +Crystal::Playground::Agent + should send json messages and return inspected value should send json messages and return inspected value +Code gen: regex literal spec + works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) works in a class variable (#10951) +Semantic: double splat + double splats named argument into arguments (1) double splats named argument into arguments (1) + errors if duplicate keys on call side with double splat and named args errors if duplicate keys on call side with double splat and named args + uses double splat restriction, matches empty uses double splat restriction, matches empty + uses restriction on double splat, doesn't match with empty named tuple (2) uses restriction on double splat, doesn't match with empty named tuple (2) + matches double splat on method with named args and regular args matches double splat on method with named args and regular args + uses restriction on double splat, means all types must be that type uses restriction on double splat, means all types must be that type + matches named args producing an empty double splat (#2678) matches named args producing an empty double splat (#2678) + matches double splat on method (empty) matches double splat on method (empty) + matches double splat with regular splat matches double splat with regular splat + errors if duplicate keys on call side with two double splats errors if duplicate keys on call side with two double splats + uses double splat in new uses double splat in new + errors missing argument with double splat errors missing argument with double splat + uses double splat restriction uses double splat restriction + matches double splat on method with named args matches double splat on method with named args + double splats named argument into arguments (2) double splats named argument into arguments (2) + overloads based on double splat restriction overloads based on double splat restriction + uses restriction on double splat, doesn't match with empty named tuple uses restriction on double splat, doesn't match with empty named tuple + uses double splat restriction with concrete type uses double splat restriction with concrete type +Crystal::Init::InitProject + correctly uses git config correctly uses git config + has proper contents has proper contents +Crystal::Command + clear_cache + clears any cached compiler files clears any cached compiler files +Code gen: void + codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable codegens void assignment in case with local variable + codegens unreachable code codegens unreachable code + allows passing void as argument to method allows passing void as argument to method + codegens no return assignment codegens no return assignment + codegens void assignment codegens void assignment + codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case codegens void assignment in case + returns void from nil functions, doesn't crash when passing value returns void from nil functions, doesn't crash when passing value +Semantic: ReferenceStorage + errors if T is a value type errors if T is a value type + errors if T is a struct type errors if T is a struct type + errors if T is a nilable type errors if T is a nilable type + allows a different name allows a different name + errors if T is a union type errors if T is a union type +Crystal::Repl::Interpreter + literals + interprets an UInt128 interprets an UInt128 + interprets a Float32 interprets a Float32 + interprets a bool (false) interprets a bool (false) + precomputes string literal length precomputes string literal length + interprets an UInt32 interprets an UInt32 + interprets an UInt64 interprets an UInt64 + interprets an Int16 interprets an Int16 + uses a string pool uses a string pool + interprets a Float64 interprets a Float64 + interprets an Int32 interprets an Int32 + interprets an Int64 interprets an Int64 + interprets a String literal interprets a String literal + interprets an Int8 interprets an Int8 + interprets an UInt16 interprets an UInt16 + interprets an Int128 interprets an Int128 + interprets an UInt8 interprets an UInt8 + interprets a char interprets a char + interprets a bool (true) interprets a bool (true) + interprets nil interprets nil + comparisons + interprets Int32 != UInt64 (true) interprets Int32 != UInt64 (true) + interprets UInt64 != Int32 (false) interprets UInt64 != Int32 (false) + interprets UInt8 < Int32 (false, right is less than zero) interprets UInt8 < Int32 (false, right is less than zero) + interprets Int32 == UInt64 (false) interprets Int32 == UInt64 (false) + interprets Int32 != UInt64 (false) interprets Int32 != UInt64 (false) + interprets UInt32 < Int32 (false) interprets UInt32 < Int32 (false) + interprets UInt64 > UInt32 (false) interprets UInt64 > UInt32 (false) + interprets Int32 != Int32 (true) interprets Int32 != Int32 (true) + interprets Int32 == UInt64 (true) interprets Int32 == UInt64 (true) + interprets UInt64 == Int32 (true when Int32 >= 0) interprets UInt64 == Int32 (true when Int32 >= 0) + interprets Bool != Bool (true) interprets Bool != Bool (true) + interprets Bool == Bool (false) interprets Bool == Bool (false) + interprets UInt8 < Int32 (false, right is greater than zero) interprets UInt8 < Int32 (false, right is greater than zero) + interprets UInt64 < Int32 (false, right is less than zero) interprets UInt64 < Int32 (false, right is less than zero) + interprets Char == Char (false) interprets Char == Char (false) + interprets Int32 == Int32 (true) interprets Int32 == Int32 (true) + interprets Int128 == Int128 (false) interprets Int128 == Int128 (false) + interprets UInt64.unsafe_mod(UInt64) interprets UInt64.unsafe_mod(UInt64) + discards comparison discards comparison + interprets Float64 < Float64 interprets Float64 < Float64 + interprets Int128 == Int128 (true) interprets Int128 == Int128 (true) + interprets UInt64 != Int32 (true) interprets UInt64 != Int32 (true) + interprets Float32 / Int32 interprets Float32 / Int32 + interprets UInt64 == Int32 (false when Int32 >= 0) interprets UInt64 == Int32 (false when Int32 >= 0) + interprets Int32 < Float64 interprets Int32 < Float64 + interprets UInt32 < Int32 (true) interprets UInt32 < Int32 (true) + interprets Float64 / Float64 interprets Float64 / Float64 + interprets Int32 < Int32 interprets Int32 < Int32 + interprets Float32 fdiv Float64 interprets Float32 fdiv Float64 + interprets UInt64 > UInt32 (true) interprets UInt64 > UInt32 (true) + interprets Float64 < Int32 interprets Float64 < Int32 + interprets Bool == Bool (true) interprets Bool == Bool (true) + interprets Bool != Bool (false) interprets Bool != Bool (false) + interprets Int32 > Float64 (true) interprets Int32 > Float64 (true) + interprets UInt64 < Int32 (false, right is greater than zero) interprets UInt64 < Int32 (false, right is greater than zero) + interprets Float64 fdiv Float32 interprets Float64 fdiv Float32 + interprets Int32 == Float64 (true) interprets Int32 == Float64 (true) + interprets UInt8 < Int32 (true, right is greater than zero) interprets UInt8 < Int32 (true, right is greater than zero) + interprets Int32 != Int32 (false) interprets Int32 != Int32 (false) + interprets UInt64 == Int32 (false when Int32 < 0) interprets UInt64 == Int32 (false when Int32 < 0) + interprets UInt64 < Int32 (true, right is greater than zero) interprets UInt64 < Int32 (true, right is greater than zero) + interprets Float32 / Float32 interprets Float32 / Float32 + interprets Int32 == Float64 (false) interprets Int32 == Float64 (false) + interprets Char == Char (true) interprets Char == Char (true) + interprets Int32 == Int32 (false) interprets Int32 == Int32 (false) + interprets Int32 > Float64 (false) interprets Int32 > Float64 (false) + local variables + interprets uninitialized interprets uninitialized + interprets variable set interprets variable set + doesn't declare variable with no type doesn't declare variable with no type + interprets variable set and get interprets variable set and get + assigns to underscore assigns to underscore + interprets variable set and get, second local var interprets variable set and get, second local var + interprets variable set with type restriction (#13023) interprets variable set with type restriction (#13023) + interprets at the class level interprets at the class level + doesn't declare variable with no type inside method doesn't declare variable with no type inside method + interprets local variable declaration (#12229) interprets local variable declaration (#12229) + interprets variable set and get with operations interprets variable set and get with operations + doesn't discard underscore right hand side doesn't discard underscore right hand side + conversion + interprets Int8::MIN#to_f32! interprets Int8::MIN#to_f32! + interprets Int8::MAX#to_f64! interprets Int8::MAX#to_f64! + interprets Int64::MIN#to_f64! interprets Int64::MIN#to_f64! + interprets Int64::MAX#to_i32! interprets Int64::MAX#to_i32! + interprets Int64::MAX#to_u64! interprets Int64::MAX#to_u64! + interprets Int32::MIN#to_i8! interprets Int32::MIN#to_i8! + interprets Int16::MAX#to_i! interprets Int16::MAX#to_i! + interprets Int32::MAX#to_u64! interprets Int32::MAX#to_u64! + interprets Int64::MAX#to_i8! interprets Int64::MAX#to_i8! + interprets Float64#to_i64! (negative) interprets Float64#to_i64! (negative) + interprets UInt8::MAX#to_f32! interprets UInt8::MAX#to_f32! + interprets UInt16::MAX#to_i! interprets UInt16::MAX#to_i! + interprets Int16::MAX#to_u32! interprets Int16::MAX#to_u32! + interprets Float64#to_i8! (negative) interprets Float64#to_i8! (negative) + interprets UInt16::MAX#to_u16! interprets UInt16::MAX#to_u16! + interprets UInt64::MAX#to_u64! interprets UInt64::MAX#to_u64! + interprets Int8::MIN#to_i16! interprets Int8::MIN#to_i16! + interprets Int64::MAX#to_u32! interprets Int64::MAX#to_u32! + interprets Int16::MAX#to_i64! interprets Int16::MAX#to_i64! + interprets Float64#to_i64! (positive) interprets Float64#to_i64! (positive) + interprets Int64::MIN#to_i16! interprets Int64::MIN#to_i16! + interprets Int64::MIN#to_u16! interprets Int64::MIN#to_u16! + interprets Int16::MIN#to_u64! interprets Int16::MIN#to_u64! + interprets Float32#to_f32! (negative) interprets Float32#to_f32! (negative) + interprets UInt64::MAX#to_f64! interprets UInt64::MAX#to_f64! + discards conversion discards conversion + interprets UInt8::MAX#to_i32! interprets UInt8::MAX#to_i32! + interprets UInt8::MAX#to_f64! interprets UInt8::MAX#to_f64! + interprets UInt32::MAX#to_i8! interprets UInt32::MAX#to_i8! + interprets Int32::MIN#to_u! interprets Int32::MIN#to_u! + interprets Int8::MAX#to_u16! interprets Int8::MAX#to_u16! + interprets UInt64::MAX#to_i64! interprets UInt64::MAX#to_i64! + interprets Int32::MAX#to_i16! interprets Int32::MAX#to_i16! + interprets Int16::MAX#to_i16! interprets Int16::MAX#to_i16! + interprets Float32#to_i32! (positive) interprets Float32#to_i32! (positive) + interprets Float32#to_i8! (positive) interprets Float32#to_i8! (positive) + interprets Float32#to_i16! (positive) interprets Float32#to_i16! (positive) + interprets Int32::MAX#to_u16! interprets Int32::MAX#to_u16! + interprets Int32::MIN#to_i! interprets Int32::MIN#to_i! + interprets Int16::MAX#to_i32! interprets Int16::MAX#to_i32! + interprets UInt32::MAX#to_u64! interprets UInt32::MAX#to_u64! + discards conversion with local var discards conversion with local var + interprets Int16::MIN#to_u8! interprets Int16::MIN#to_u8! + interprets UInt8::MAX#to_i8! interprets UInt8::MAX#to_i8! + interprets Int64::MIN#to_f32! interprets Int64::MIN#to_f32! + interprets Int64::MIN#to_u32! interprets Int64::MIN#to_u32! + interprets UInt8::MAX#to_i16! interprets UInt8::MAX#to_i16! + interprets Int64::MAX#to_i64! interprets Int64::MAX#to_i64! + interprets Float32#to_i! (negative) interprets Float32#to_i! (negative) + interprets Float32#to_u32! (positive) interprets Float32#to_u32! (positive) + interprets Float64#to_f64! (negative) interprets Float64#to_f64! (negative) + interprets Int32::MIN#to_u64! interprets Int32::MIN#to_u64! + interprets UInt8::MAX#to_u8! interprets UInt8::MAX#to_u8! + interprets Float32#to_f64! (positive) interprets Float32#to_f64! (positive) + interprets Int32::MIN#to_f64! interprets Int32::MIN#to_f64! + interprets Float64#to_u! (positive) interprets Float64#to_u! (positive) + interprets Float64#to_f32! (negative) interprets Float64#to_f32! (negative) + interprets Int64::MIN#to_u64! interprets Int64::MIN#to_u64! + interprets Int64::MIN#to_u! interprets Int64::MIN#to_u! + interprets Int8::MAX#to_i64! interprets Int8::MAX#to_i64! + interprets Float64#to_i32! (positive) interprets Float64#to_i32! (positive) + interprets UInt8::MAX#to_u64! interprets UInt8::MAX#to_u64! + interprets UInt16::MAX#to_i16! interprets UInt16::MAX#to_i16! + interprets Int8::MIN#to_u32! interprets Int8::MIN#to_u32! + interprets UInt32::MAX#to_u! interprets UInt32::MAX#to_u! + interprets Int32::MAX#to_i32! interprets Int32::MAX#to_i32! + interprets UInt64::MAX#to_i32! interprets UInt64::MAX#to_i32! + interprets UInt16::MAX#to_f64! interprets UInt16::MAX#to_f64! + interprets Int32::MIN#to_i64! interprets Int32::MIN#to_i64! + interprets UInt8::MAX#to_u16! interprets UInt8::MAX#to_u16! + interprets UInt16::MAX#to_u32! interprets UInt16::MAX#to_u32! + interprets UInt64::MAX#to_u8! interprets UInt64::MAX#to_u8! + interprets Float32#to_i32! (negative) interprets Float32#to_i32! (negative) + interprets UInt32::MAX#to_i16! interprets UInt32::MAX#to_i16! + interprets Int32::MIN#to_i16! interprets Int32::MIN#to_i16! + interprets Int16::MIN#to_u32! interprets Int16::MIN#to_u32! + interprets UInt64::MAX#to_i! interprets UInt64::MAX#to_i! + interprets UInt16::MAX#to_u64! interprets UInt16::MAX#to_u64! + Int32#unsafe_chr Int32#unsafe_chr + interprets UInt64::MAX#to_i8! interprets UInt64::MAX#to_i8! + interprets Int16::MIN#to_i64! interprets Int16::MIN#to_i64! + interprets Int64::MIN#to_u8! interprets Int64::MIN#to_u8! + interprets Int32::MIN#to_u8! interprets Int32::MIN#to_u8! + interprets Float32#to_i64! (negative) interprets Float32#to_i64! (negative) + interprets Float32#to_i64! (positive) interprets Float32#to_i64! (positive) + interprets UInt32::MAX#to_i! interprets UInt32::MAX#to_i! + interprets Int64::MAX#to_i! interprets Int64::MAX#to_i! + interprets Int64::MIN#to_i32! interprets Int64::MIN#to_i32! + interprets Int16::MAX#to_f32! interprets Int16::MAX#to_f32! + interprets Int64::MAX#to_u16! interprets Int64::MAX#to_u16! + interprets Int8::MAX#to_i32! interprets Int8::MAX#to_i32! + interprets Float32#to_i! (positive) interprets Float32#to_i! (positive) + interprets UInt32::MAX#to_u8! interprets UInt32::MAX#to_u8! + interprets Int32::MIN#to_i32! interprets Int32::MIN#to_i32! + interprets Int64::MAX#to_u! interprets Int64::MAX#to_u! + interprets Float64#to_f64! (positive) interprets Float64#to_f64! (positive) + interprets Int8::MIN#to_u8! interprets Int8::MIN#to_u8! + interprets UInt64::MAX#to_u32! interprets UInt64::MAX#to_u32! + interprets Float64#to_u64! (positive) interprets Float64#to_u64! (positive) + interprets Int16::MAX#to_i8! interprets Int16::MAX#to_i8! + interprets Int32::MIN#to_f32! interprets Int32::MIN#to_f32! + interprets Float32#to_f32! (positive) interprets Float32#to_f32! (positive) + interprets Int64::MIN#to_i! interprets Int64::MIN#to_i! + interprets Float64#to_u8! (positive) interprets Float64#to_u8! (positive) + interprets UInt32::MAX#to_u16! interprets UInt32::MAX#to_u16! + interprets Int64::MIN#to_i8! interprets Int64::MIN#to_i8! + interprets Float64#to_u32! (positive) interprets Float64#to_u32! (positive) + interprets Int64::MAX#to_u8! interprets Int64::MAX#to_u8! + interprets Int16::MAX#to_u8! interprets Int16::MAX#to_u8! + interprets Int8::MAX#to_u32! interprets Int8::MAX#to_u32! + interprets Int32::MAX#to_u32! interprets Int32::MAX#to_u32! + interprets Int8::MAX#to_u8! interprets Int8::MAX#to_u8! + interprets UInt16::MAX#to_u8! interprets UInt16::MAX#to_u8! + interprets Float64#to_f32! (positive) interprets Float64#to_f32! (positive) + interprets Int8::MAX#to_u64! interprets Int8::MAX#to_u64! + interprets Int8::MIN#to_i64! interprets Int8::MIN#to_i64! + interprets UInt16::MAX#to_u! interprets UInt16::MAX#to_u! + interprets Float32#to_u16! (positive) interprets Float32#to_u16! (positive) + interprets Float64#to_i! (negative) interprets Float64#to_i! (negative) + interprets Int8::MAX#to_u! interprets Int8::MAX#to_u! + interprets Int16::MIN#to_u! interprets Int16::MIN#to_u! + interprets Float32#to_u64! (positive) interprets Float32#to_u64! (positive) + interprets UInt64::MAX#to_i16! interprets UInt64::MAX#to_i16! + interprets Int32::MAX#to_u! interprets Int32::MAX#to_u! + interprets UInt8::MAX#to_u! interprets UInt8::MAX#to_u! + interprets Int8::MIN#to_u64! interprets Int8::MIN#to_u64! + interprets Int16::MAX#to_f64! interprets Int16::MAX#to_f64! + interprets Float64#to_i8! (positive) interprets Float64#to_i8! (positive) + interprets Int16::MIN#to_i32! interprets Int16::MIN#to_i32! + interprets Float32#to_i16! (negative) interprets Float32#to_i16! (negative) + interprets Int32::MAX#to_i64! interprets Int32::MAX#to_i64! + interprets Int16::MIN#to_f64! interprets Int16::MIN#to_f64! + interprets Int8::MAX#to_i16! interprets Int8::MAX#to_i16! + interprets Int16::MIN#to_f32! interprets Int16::MIN#to_f32! + interprets Int8::MIN#to_u16! interprets Int8::MIN#to_u16! + interprets UInt64::MAX#to_u16! interprets UInt64::MAX#to_u16! + interprets Float32#to_i8! (negative) interprets Float32#to_i8! (negative) + interprets Int64::MIN#to_i64! interprets Int64::MIN#to_i64! + interprets Int16::MAX#to_u64! interprets Int16::MAX#to_u64! + interprets UInt16::MAX#to_f32! interprets UInt16::MAX#to_f32! + interprets Int32::MIN#to_u16! interprets Int32::MIN#to_u16! + interprets UInt8::MAX#to_i64! interprets UInt8::MAX#to_i64! + interprets UInt16::MAX#to_i8! interprets UInt16::MAX#to_i8! + interprets UInt8::MAX#to_i! interprets UInt8::MAX#to_i! + interprets Int32::MIN#to_u32! interprets Int32::MIN#to_u32! + interprets UInt32::MAX#to_f32! interprets UInt32::MAX#to_f32! + interprets Int64::MAX#to_i16! interprets Int64::MAX#to_i16! + interprets UInt32::MAX#to_f64! interprets UInt32::MAX#to_f64! + interprets UInt32::MAX#to_i64! interprets UInt32::MAX#to_i64! + interprets Int32::MAX#to_i! interprets Int32::MAX#to_i! + interprets Int8::MIN#to_i! interprets Int8::MIN#to_i! + interprets UInt32::MAX#to_u32! interprets UInt32::MAX#to_u32! + interprets UInt8::MAX#to_u32! interprets UInt8::MAX#to_u32! + interprets Float32#to_f64! (negative) interprets Float32#to_f64! (negative) + interprets Int16::MIN#to_u16! interprets Int16::MIN#to_u16! + interprets UInt32::MAX#to_i32! interprets UInt32::MAX#to_i32! + interprets Int8::MAX#to_i8! interprets Int8::MAX#to_i8! + interprets Float64#to_i16! (negative) interprets Float64#to_i16! (negative) + interprets Int32::MAX#to_f64! interprets Int32::MAX#to_f64! + interprets Int32::MAX#to_i8! interprets Int32::MAX#to_i8! + interprets Int8::MIN#to_f64! interprets Int8::MIN#to_f64! + interprets Float64#to_i32! (negative) interprets Float64#to_i32! (negative) + interprets Int8::MIN#to_u! interprets Int8::MIN#to_u! + interprets Int64::MAX#to_f64! interprets Int64::MAX#to_f64! + interprets Int32::MAX#to_u8! interprets Int32::MAX#to_u8! + interprets Int8::MIN#to_i32! interprets Int8::MIN#to_i32! + interprets UInt16::MAX#to_i64! interprets UInt16::MAX#to_i64! + interprets Float32#to_u! (positive) interprets Float32#to_u! (positive) + interprets Int32::MAX#to_f32! interprets Int32::MAX#to_f32! + interprets Float64#to_u16! (positive) interprets Float64#to_u16! (positive) + interprets UInt64::MAX#to_f32! interprets UInt64::MAX#to_f32! + interprets Char#ord interprets Char#ord + interprets Int16::MAX#to_u! interprets Int16::MAX#to_u! + UInt8#unsafe_chr UInt8#unsafe_chr + interprets Float32#to_u8! (positive) interprets Float32#to_u8! (positive) + interprets UInt64::MAX#to_u! interprets UInt64::MAX#to_u! + interprets Float64#to_i16! (positive) interprets Float64#to_i16! (positive) + interprets Int8::MIN#to_i8! interprets Int8::MIN#to_i8! + interprets Int8::MAX#to_f32! interprets Int8::MAX#to_f32! + interprets Int16::MAX#to_u16! interprets Int16::MAX#to_u16! + interprets Float64#to_i! (positive) interprets Float64#to_i! (positive) + interprets UInt16::MAX#to_i32! interprets UInt16::MAX#to_i32! + interprets Int16::MIN#to_i! interprets Int16::MIN#to_i! + interprets Int64::MAX#to_f32! interprets Int64::MAX#to_f32! + interprets Int16::MIN#to_i16! interprets Int16::MIN#to_i16! + interprets Int16::MIN#to_i8! interprets Int16::MIN#to_i8! + interprets Int8::MAX#to_i! interprets Int8::MAX#to_i! + overflow + * + overlows on 20 * 214748364 overlows on 20 * 214748364 + overlows on 10_u16 * 6600 overlows on 10_u16 * 6600 + overlows on 10_i8 * 14 overlows on 10_i8 * 14 + overlows on 10_i16 * 3300 overlows on 10_i16 * 3300 + overlows on 20_u64 * 1844674407370955161_i64 overlows on 20_u64 * 1844674407370955161_i64 + overlows on 20_i64 * 922337203685477580_i64 overlows on 20_i64 * 922337203685477580_i64 + overlows on 20_u32 * 429496729 overlows on 20_u32 * 429496729 + overlows on 10_u8 * 26 overlows on 10_u8 * 26 + - + overlows on 1_i64 - 9223372036854775810_u64 overlows on 1_i64 - 9223372036854775810_u64 + overlows on 1_u16 - 2 overlows on 1_u16 - 2 + overlows on 1_i16 - 32770 overlows on 1_i16 - 32770 + overlows on 1_u64 - 2 overlows on 1_u64 - 2 + overlows on 1_u8 - 2 overlows on 1_u8 - 2 + overlows on 1_u32 - 2 overlows on 1_u32 - 2 + overlows on 1 - 2147483650_i64 overlows on 1 - 2147483650_i64 + overlows on 1_i8 - 256 overlows on 1_i8 - 256 + conversion + overlows on -1_i16.to_u64 overlows on -1_i16.to_u64 + overlows on 32768_f64.to_i16 overlows on 32768_f64.to_i16 + overlows on 128_f64.to_i8 overlows on 128_f64.to_i8 + overlows on 128_u32.to_i8 overlows on 128_u32.to_i8 + overlows on 256_f64.to_u8 overlows on 256_f64.to_u8 + overlows on -1_i8.to_u64 overlows on -1_i8.to_u64 + overlows on 65536_f32.to_u16 overlows on 65536_f32.to_u16 + overlows on 256_f32.to_u8 overlows on 256_f32.to_u8 + overlows on 2147483648_u32.to_i32 overlows on 2147483648_u32.to_i32 + overlows on 32768_u32.to_i16 overlows on 32768_u32.to_i16 + overlows on -1_i64.to_u8 overlows on -1_i64.to_u8 + overlows on -1.to_u32 overlows on -1.to_u32 + overlows on -1_i16.to_u16 overlows on -1_i16.to_u16 + overlows on 128_f32.to_i8 overlows on 128_f32.to_i8 + overlows on -1_i8.to_u8 overlows on -1_i8.to_u8 + overlows on 1.7976931348623157e+308.to_f32 overlows on 1.7976931348623157e+308.to_f32 + overlows on -1_i64.to_u16 overlows on -1_i64.to_u16 + overlows on 65536_f64.to_u16 overlows on 65536_f64.to_u16 + overlows on 128_u64.to_i8 overlows on 128_u64.to_i8 + overlows on 2147483648_f64.to_i32 overlows on 2147483648_f64.to_i32 + overlows on -1_i64.to_u64 overlows on -1_i64.to_u64 + overlows on -1.to_u64 overlows on -1.to_u64 + overlows on 32768_u64.to_i16 overlows on 32768_u64.to_i16 + overlows on -1.to_u16 overlows on -1.to_u16 + overlows on -1_i16.to_u8 overlows on -1_i16.to_u8 + overlows on 128_u16.to_i8 overlows on 128_u16.to_i8 + overlows on 2147483648_u64.to_i32 overlows on 2147483648_u64.to_i32 + overlows on 128_u8.to_i8 overlows on 128_u8.to_i8 + overlows on -1.to_u8 overlows on -1.to_u8 + overlows on -1_i8.to_u32 overlows on -1_i8.to_u32 + overlows on -1_i64.to_u32 overlows on -1_i64.to_u32 + overlows on 32768_f32.to_i16 overlows on 32768_f32.to_i16 + overlows on 9223372036854775808_u64.to_i64 overlows on 9223372036854775808_u64.to_i64 + overlows on 32768_u16.to_i16 overlows on 32768_u16.to_i16 + overlows on 4294967296_f64.to_u32 overlows on 4294967296_f64.to_u32 + overlows on -1_i8.to_u16 overlows on -1_i8.to_u16 + overlows on -1_i16.to_u32 overlows on -1_i16.to_u32 + + + overlows on 1_u8 + 255 overlows on 1_u8 + 255 + overlows on 1_u32 + 4294967295_i64 overlows on 1_u32 + 4294967295_i64 + overlows on 1_i64 + 9223372036854775807_i64 overlows on 1_i64 + 9223372036854775807_i64 + overlows on 1_u16 + 65535 overlows on 1_u16 + 65535 + overlows on 1_u64 + 18446744073709551615_u64 overlows on 1_u64 + 18446744073709551615_u64 + overlows on 1 + 2147483647 overlows on 1 + 2147483647 + overlows on 1_i16 + 32767 overlows on 1_i16 + 32767 + overlows on 1_i8 + 128 overlows on 1_i8 + 128 + logical operations + does math primitive on union does math primitive on union + interprets not for generic class instance type interprets not for generic class instance type + interprets not for bool false interprets not for bool false + interprets not for nilable proc type (false) interprets not for nilable proc type (false) + interprets not for mixed union (false) interprets not for mixed union (false) + interprets not for mixed union (true) interprets not for mixed union (true) + interprets not for generic module interprets not for generic module + interprets not for nilable type (true) interprets not for nilable type (true) + does math convert on union does math convert on union + interprets not for bool true interprets not for bool true + interprets not for bool false interprets not for bool false + interprets not for nilable type (true) interprets not for nilable type (true) + interprets not for nil type interprets not for nil type + discards nil not discards nil not + interprets not for generic module metaclass interprets not for generic module metaclass + interprets not for nilable type (false) interprets not for nilable type (false) + discards bool not discards bool not + interprets not for nilable proc type (true) interprets not for nilable proc type (true) + interprets not for mixed union (nil) interprets not for mixed union (nil) + interprets not for module (#12918) interprets not for module (#12918) + interprets not for nilable type (false) interprets not for nilable type (false) + interprets not for generic class instance metaclass interprets not for generic class instance metaclass + interprets not for mixed union (other) interprets not for mixed union (other) + interprets not for nil interprets not for nil + math + interprets Float64 * Float64 interprets Float64 * Float64 + interprets UInt32 - Int32 interprets UInt32 - Int32 + interprets Float64 + Float64 interprets Float64 + Float64 + interprets Int32 + Float64 interprets Int32 + Float64 + interprets UInt64 & Int32 interprets UInt64 & Int32 + interprets Float32 + Float64 interprets Float32 + Float64 + interprets Float64 - Float64 interprets Float64 - Float64 + interprets Int32 * Int32 interprets Int32 * Int32 + interprets Int128 + Int32 interprets Int128 + Int32 + interprets Int8 + Int8 interprets Int8 + Int8 + interprets Int32 &+ Int32 interprets Int32 &+ Int32 + interprets Int32.unsafe_shl(Int32) with self interprets Int32.unsafe_shl(Int32) with self + interprets UInt64 | UInt32 interprets UInt64 | UInt32 + interprets Float64 + Int32 interprets Float64 + Int32 + interprets Int64 + Int64 interprets Int64 + Int64 + interprets UInt8 | Int32 interprets UInt8 | Int32 + interprets Int32 &* Int32 interprets Int32 &* Int32 + interprets Int32 - Int32 interprets Int32 - Int32 + interprets Int32 + Int32 interprets Int32 + Int32 + discards math discards math + interprets UInt64 * Int32 interprets UInt64 * Int32 + interprets Int32 &- Int32 interprets Int32 &- Int32 +Semantic: NoReturn + computes NoReturn in a lazy way inside if then (#314) (4) computes NoReturn in a lazy way inside if then (#314) (4) + computes NoReturn in a lazy way inside if then (#314) (1) computes NoReturn in a lazy way inside if then (#314) (1) + computes NoReturn in a lazy way inside if then (#314) (3) computes NoReturn in a lazy way inside if then (#314) (3) + types union of NoReturn and something else types union of NoReturn and something else + computes NoReturn in a lazy way inside if else (#314) (4) computes NoReturn in a lazy way inside if else (#314) (4) + computes NoReturn in a lazy way inside if else (#314) (3) computes NoReturn in a lazy way inside if else (#314) (3) + computes NoReturn in a lazy way inside if then (#314) (5) computes NoReturn in a lazy way inside if then (#314) (5) + types as NoReturn even if Nil return type is forced (#3096) types as NoReturn even if Nil return type is forced (#3096) + computes NoReturn in a lazy way inside if else (#314) (1) computes NoReturn in a lazy way inside if else (#314) (1) + types as NoReturn if typeof(exp)'s exp is NoReturn types as NoReturn if typeof(exp)'s exp is NoReturn + assumes if condition's type filters when else is no return assumes if condition's type filters when else is no return + types call to LibC.exit as NoReturn types call to LibC.exit as NoReturn + types exception handler as NoReturn if ensure is NoReturn types exception handler as NoReturn if ensure is NoReturn + types with no return even if code follows types with no return even if code follows + types union of NoReturns types union of NoReturns + computes NoReturn in a lazy way inside if then (#314) (2) computes NoReturn in a lazy way inside if then (#314) (2) + computes NoReturn in a lazy way inside if else (#314) (5) computes NoReturn in a lazy way inside if else (#314) (5) + computes NoReturn in a lazy way inside if else (#314) (2) computes NoReturn in a lazy way inside if else (#314) (2) + types raise as NoReturn types raise as NoReturn +Code gen: hash literal spec + creates custom generic hash via alias (1) creates custom generic hash via alias (1) + assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works assignment in hash-like literal works + creates custom generic hash in module (#5684) creates custom generic hash in module (#5684) + creates custom generic hash with type vars creates custom generic hash with type vars + doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) doesn't crash on hash literal with proc pointer (#646) + creates custom non-generic hash creates custom non-generic hash + assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works assignment in hash literal works + creates custom generic hash creates custom generic hash + creates custom generic hash via alias (2) creates custom generic hash via alias (2) + creates custom non-generic hash in module creates custom non-generic hash in module unreachable - finds method called from proc finds method called from proc - finds methods with proc parameter finds methods with proc parameter - finds method called from block finds method called from block - finds method called from instance variable initializer finds method called from instance variable initializer - finds yielding methods finds yielding methods - finds abstract method finds abstract method - finds virtual method finds virtual method - finds method called from expanded macro expression finds method called from expanded macro expression - finds method with free variable finds method with free variable - finds methods in generic type finds methods in generic type - finds class methods finds class methods finds instance methods finds instance methods - tallies calls tallies calls - finds methods called from reachable code finds methods called from reachable code + finds method called from expanded macro finds method called from expanded macro + finds instance methods in nested types finds instance methods in nested types + finds method with `previous_def` finds method with `previous_def` + finds method called from expanded macro expression finds method called from expanded macro expression + finds top level methods finds top level methods finds initializer finds initializer ignores autogenerated enum predicates ignores autogenerated enum predicates - finds top level methods finds top level methods + finds method called from block finds method called from block + finds class methods finds class methods finds method with `super` finds method with `super` - finds method in abstract type finds method in abstract type - finds instance methods in nested types finds instance methods in nested types - finds method called from expanded macro finds method called from expanded macro handles circular hierarchy references (#14034) handles circular hierarchy references (#14034) + finds abstract method finds abstract method + finds virtual method finds virtual method + finds method called from proc finds method called from proc + tallies calls tallies calls finds shadowed method finds shadowed method - finds method with `previous_def` finds method with `previous_def` -codegen: previous_def - correctly passes named arguments correctly passes named arguments - codegens previous def when inside fun and forwards args codegens previous def when inside fun and forwards args - codegens previous def codegens previous def - codegens previous def when inside fun with self codegens previous def when inside fun with self -Crystal::Loader - .default_search_paths - LD_LIBRARY_PATH LD_LIBRARY_PATH - DYLD_LIBRARY_PATH DYLD_LIBRARY_PATH - .read_ld_conf - with include with include - basic basic - dynlib - does not find global symbols does not find global symbols - validate that lib handles are properly closed validate that lib handles are properly closed - #load_file? - finds function symbol finds function symbol - #load_library? - does not implicitly find dependencies does not implicitly find dependencies - full path full path - lookup in order lookup in order - library name library name - .parse - prepends directory paths before default search paths prepends directory paths before default search paths - parses library names parses library names - parses static parses static - parses file paths parses file paths - parses directory paths parses directory paths -Parser warnings - warns on missing space before colon - in block param type restriction in block param type restriction - in anonymous block param type restriction in anonymous block param type restriction - in type declaration in type declaration - in return type restriction in return type restriction - warns on suffix-less UInt64 literals > Int64::MAX warns on suffix-less UInt64 literals > Int64::MAX -Crystal::Repl::Interpreter - tuple - extends sign when doing to_i32 extends sign when doing to_i32 - interprets tuple literal and access by known index interprets tuple literal and access by known index - interprets tuple literal of different types (1) interprets tuple literal of different types (1) - interprets tuple metaclass indexer interprets tuple metaclass indexer - interprets tuple literal of different types (2) interprets tuple literal of different types (2) - discards tuple (#12383) discards tuple (#12383) - interprets tuple self interprets tuple self - discards tuple access discards tuple access - unpacks tuple in block arguments unpacks tuple in block arguments - interprets tuple metaclass range indexer interprets tuple metaclass range indexer - interprets tuple range indexer interprets tuple range indexer - interprets tuple range indexer (2) interprets tuple range indexer (2) - does tuple indexer on union does tuple indexer on union -read_file? - with relative path - reads file (doesn't exist) reads file (doesn't exist) - with absolute path - reads file (doesn't exist) reads file (doesn't exist) -Crystal::Repl::Interpreter - named tuple - discards named tuple (#12383) discards named tuple (#12383) - interprets named tuple literal and access by known index interprets named tuple literal and access by known index - interprets named tuple metaclass indexer interprets named tuple metaclass indexer -Codegen: responds_to? - works with generic virtual module (2) (#8334) works with generic virtual module (2) (#8334) - codegens responds_to? with nilable gives false because other type 1 codegens responds_to? with nilable gives false because other type 1 - works with generic virtual module (1) works with generic virtual module (1) - codegens responds_to? with generic class (2) codegens responds_to? with generic class (2) - works with virtual type works with virtual type - codegens responds_to? false for simple type codegens responds_to? false for simple type - works with generic virtual superclass (2) works with generic virtual superclass (2) - codegens responds_to? true for simple type codegens responds_to? true for simple type - works with generic virtual superclass (1) works with generic virtual superclass (1) - codegens responds_to? with generic class (1) codegens responds_to? with generic class (1) - doesn't error if result is discarded (#14113) doesn't error if result is discarded (#14113) - codegens responds_to? with union gives false codegens responds_to? with union gives false - works with two virtual types works with two virtual types - does for generic instance type metaclass (#4353) does for generic instance type metaclass (#4353) - codegens responds_to? with nilable gives false because other type 2 codegens responds_to? with nilable gives false because other type 2 - works with virtual class type (2) (#1926) works with virtual class type (2) (#1926) - works with module works with module - codegens responds_to? with union gives true codegens responds_to? with union gives true - codegens responds_to? with nilable gives true codegens responds_to? with nilable gives true - works with virtual class type (1) (#1926) works with virtual class type (1) (#1926) -Semantic: return - allows nilable return type to match subclasses (#1735) allows nilable return type to match subclasses (#1735) - can use type var as return type with an included generic module can use type var as return type with an included generic module - can use non-type free var in return type (2) (#6543) can use non-type free var in return type (2) (#6543) - forms a tuple from multiple return values forms a tuple from multiple return values - can use free var in return type (#2492) can use free var in return type (#2492) - errors on return in top level errors on return in top level - types bug (#1823) types bug (#1823) - allows returning NoReturn instead of the wanted type allows returning NoReturn instead of the wanted type - can use non-type free var in return type (#6543) can use non-type free var in return type (#6543) - can use type var as return type (#1226) can use type var as return type (#1226) - infers return type with many returns (1) infers return type with many returns (1) - infers return type infers return type - flattens splats inside multiple return values flattens splats inside multiple return values - errors if non-type free var cannot be inferred errors if non-type free var cannot be inferred - types return if true types return if true - doesn't confuse return type from base class doesn't confuse return type from base class - can use type var as return type with an inherited generic class can use type var as return type with an inherited generic class - infers return type with many returns (2) infers return type with many returns (2) -Crystal::TablePrint - colspan a cell that fits the available size colspan a cell that fits the available size - aligns cell content aligns cell content - single cell single cell - aligns columns borders aligns columns borders - single row with separator single row with separator - multiple rows with separator multiple rows with separator - rows with horizontal separators rows with horizontal separators -Crystal::Command::FlagsVisitor - different flags different flags - only macro only macro - unique flags unique flags -Code gen: var - codegens bug with instance vars and ssa codegens bug with instance vars and ssa - codegens ivar assignment when not-nil type filter applies codegens ivar assignment when not-nil type filter applies - codegens var codegens var - works with typeof with assignment (#828) works with typeof with assignment (#828) - codegens bug with var, while, if, break and ssa codegens bug with var, while, if, break and ssa - assigns to underscore assigns to underscore - codegens assignment that can never be reached codegens assignment that can never be reached - codegens var with type declaration codegens var with type declaration - codegens bug with union of int, nil and string (1): assigning nil to union must fill all zeros codegens bug with union of int, nil and string (1): assigning nil to union must fill all zeros - codegens bug with union of int, nil and string (2): assigning nil to union must fill all zeros codegens bug with union of int, nil and string (2): assigning nil to union must fill all zeros -.system - successful command with output successful command with output -sh: 1: commanddoesnotexist: not found - command does not exist command does not exist - successful command successful command - failing command failing command -Code gen: splat - splats with default value (3) splats with default value (3) - splats on call splats on call - does #2407 does #2407 - splats with default value splats with default value - splats in initialize splats in initialize - splats with another arg splats with another arg - splats splats - splats without args splats without args - splats with default value (2) splats with default value (2) - evaluates splat argument just once (#2677) evaluates splat argument just once (#2677) -Init invocation - doesn't error if files will be overwritten by a generated file and --force is used doesn't error if files will be overwritten by a generated file and --force is used - prints error if a file is already present prints error if a file is already present - honors the custom set directory name honors the custom set directory name - produces valid yaml file produces valid yaml file - doesn't error when asked to skip existing files doesn't error when asked to skip existing files - errors if files will be overwritten by a generated file errors if files will be overwritten by a generated file -Code gen: class - codegens method from another method without obj and accesses instance vars codegens method from another method without obj and accesses instance vars - doesn't crash on instance variable assigned a proc, and never instantiated (#923) doesn't crash on instance variable assigned a proc, and never instantiated (#923) - resolves type declaration when accessing instance var (#348) resolves type declaration when accessing instance var (#348) - uses number type var uses number type var - does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class does to_s for class - doesn't crash on #1216 (reduced) doesn't crash on #1216 (reduced) - reads a virtual type instance var reads a virtual type instance var - transfers initializer from generic module to non-generic class transfers initializer from generic module to non-generic class - does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) does to_s for virtual metaclass type (2) - reads a union type instance var (mixed union, first type) reads a union type instance var (mixed union, first type) - doesn't crash on abstract class never instantiated (#2840) doesn't crash on abstract class never instantiated (#2840) - runs with nil instance var when inheriting runs with nil instance var when inheriting - codegens virtual call that calls another method codegens virtual call that calls another method - reads a union type instance var (reference union, second type) reads a union type instance var (reference union, second type) - codegens singleton (#718) codegens singleton (#718) - codegens assignment of generic metaclasses (4) (#10394) codegens assignment of generic metaclasses (4) (#10394) - does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) does to_s for virtual metaclass type (3) - transfers initializer from generic module to generic class transfers initializer from generic module to generic class - changes instance variable in method (ssa bug) changes instance variable in method (ssa bug) - doesn't skip false initializers (#3272) doesn't skip false initializers (#3272) - never considers read instance var as closure (#12181) never considers read instance var as closure (#12181) - invokes class method inside instance method (#1119) invokes class method inside instance method (#1119) - works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) works with array in variable initializer in generic type (#855) - codegens assignment of generic metaclasses, base is non-generic (2) (#10394) codegens assignment of generic metaclasses, base is non-generic (2) (#10394) - reads other instance var reads other instance var - calls class method without self calls class method without self - assigns type to reference union type assigns type to reference union type - makes .class always be a virtual type even if no subclasses makes .class always be a virtual type even if no subclasses - doesn't crash on #1216 with pointerof doesn't crash on #1216 with pointerof - codegens assignment of generic metaclasses, base is non-generic (1) (#10394) codegens assignment of generic metaclasses, base is non-generic (1) (#10394) - doesn't crash on #1216 doesn't crash on #1216 - works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) works with array in variable initializer in non-generic type (#855) - codegens assignment of generic metaclasses (2) (#10394) codegens assignment of generic metaclasses (2) (#10394) - codegens assignment of generic metaclasses (1) (#10394) codegens assignment of generic metaclasses (1) (#10394) - allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope allows using self in class scope - codegens virtual class method codegens virtual class method - gets class of virtual type gets class of virtual type - builds generic class bug builds generic class bug - calls method on Class class calls method on Class class - can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) can use a Main class (#1628) - codegens method of class union including Int (#1476) codegens method of class union including Int (#1476) - codegens class with recursive tuple to class (#4520) codegens class with recursive tuple to class (#4520) - codegens virtual method of generic class codegens virtual method of generic class - codegens new which calls initialize codegens new which calls initialize - does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class does to_s on class - codegens virtual generic class instance metaclass (#3819) codegens virtual generic class instance metaclass (#3819) - allows using self in class scope allows using self in class scope - codegens method call of instance var codegens method call of instance var - doesn't crash if not using undefined instance variable in superclass doesn't crash if not using undefined instance variable in superclass - codegens virtual metaclass union bug (#2597) codegens virtual metaclass union bug (#2597) - does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) does to_s for virtual metaclass type (1) - doesn't skip zero initializers (#3272) doesn't skip zero initializers (#3272) - runs with nilable instance var runs with nilable instance var - allows fixing an instance variable's type allows fixing an instance variable's type - codegens bug #168 codegens bug #168 - codegens class method codegens class method - reads a union type instance var (mixed union, second type) reads a union type instance var (mixed union, second type) - calls class method without self (2) calls class method without self (2) - allows initializing var with constant allows initializing var with constant - codegens instance var codegens instance var - can assign virtual metaclass to virtual metaclass (#3007) can assign virtual metaclass to virtual metaclass (#3007) - notifies superclass recursively on inheritance (#576) notifies superclass recursively on inheritance (#576) - codegens initialize with instance var codegens initialize with instance var - reads a union type instance var (reference union, first type) reads a union type instance var (reference union, first type) - codegens assignment of generic metaclasses (3) (#10394) codegens assignment of generic metaclasses (3) (#10394) - transfers initializer from module to generic class transfers initializer from module to generic class - runs instance variable initializer at the class level, for generic type runs instance variable initializer at the class level, for generic type - codegens call to same instance codegens call to same instance - codegens recursive type codegens recursive type - runs instance variable initializer at the class level runs instance variable initializer at the class level -Crystal::Repl::Interpreter - symbol - symbol equality symbol equality - Symbol#to_i Symbol#to_i - Symbol#to_s Symbol#to_s -Semantic: sizeof - gives error if using instance_sizeof on a struct gives error if using instance_sizeof on a struct - gives error if using instance_sizeof on a union type (#8349) gives error if using instance_sizeof on a union type (#8349) - types sizeof types sizeof - gives error if using instance_sizeof on something that's not a class gives error if using instance_sizeof on something that's not a class - gives error if using instance_sizeof on an abstract struct (#11855) gives error if using instance_sizeof on an abstract struct (#11855) - types alignof NoReturn (missing type) (#5717) types alignof NoReturn (missing type) (#5717) - types instance_sizeof types instance_sizeof - types instance_sizeof NoReturn (missing type) (#5717) types instance_sizeof NoReturn (missing type) (#5717) - gives error if using instance_sizeof on a module gives error if using instance_sizeof on a module - errors on sizeof uninstantiated generic type (#6415) errors on sizeof uninstantiated generic type (#6415) - types instance_alignof NoReturn (missing type) (#5717) types instance_alignof NoReturn (missing type) (#5717) - gives error if using instance_sizeof on an abstract struct with multiple subtypes (#11855) gives error if using instance_sizeof on an abstract struct with multiple subtypes (#11855) - types alignof types alignof - types instance_alignof types instance_alignof - gives error if using instance_sizeof on a generic type without type vars gives error if using instance_sizeof on a generic type without type vars - types sizeof NoReturn (missing type) (#5717) types sizeof NoReturn (missing type) (#5717) - gives error if using instance_sizeof on a metaclass gives error if using instance_sizeof on a metaclass -Crystal::Doc::Macro - args_to_s - shows double splat arg shows double splat arg - shows external name of arg with quotes and escaping shows external name of arg with quotes and escaping - shows simple arg and splat arg shows simple arg and splat arg - shows simple args shows simple args - shows block arg shows block arg - shows simple arg and block arg shows simple arg and block arg - shows simple arg and double splat arg shows simple arg and double splat arg - shows double splat arg shows double splat arg - shows splat arg shows splat arg - shows default value with highlighting shows default value with highlighting - shows external name of arg shows external name of arg -Semantic: method_missing - finds method_missing with 'with ... yield' finds method_missing with 'with ... yield' - errors if method_missing expands to an incorrect method errors if method_missing expands to an incorrect method - does method missing for generic type does method missing for generic type - does error in method_missing if wrong number of params does error in method_missing if wrong number of params - does error in method_missing macro with virtual type does error in method_missing macro with virtual type - errors if method_missing expands to multiple methods errors if method_missing expands to multiple methods - doesn't look up method_missing in with_yield_scope if call has a receiver (#12097) doesn't look up method_missing in with_yield_scope if call has a receiver (#12097) -Normalize: chained comparisons - normalizes two comparisons with literal normalizes two comparisons with literal - normalizes one comparison with call normalizes one comparison with call - normalizes two comparisons with calls normalizes two comparisons with calls - normalizes one comparison with literal normalizes one comparison with literal - normalizes one comparison with var normalizes one comparison with var -Semantic: module - calls super on included generic module and finds type var (2) calls super on included generic module and finds type var (2) - instantiates generic variadic module, accesses T from instance method through generic include, more args instantiates generic variadic module, accesses T from instance method through generic include, more args - errors when extending self and self defines instance vars (#9568) errors when extending self and self defines instance vars (#9568) - instantiates generic variadic module, accesses T from instance method instantiates generic variadic module, accesses T from instance method - includes generic module with self (check argument type, success) includes generic module with self (check argument type, success) - errors when recursively extending module that defines instance vars errors when recursively extending module that defines instance vars - types pointer of module types pointer of module - allows overloading with included generic module allows overloading with included generic module - can use generic module as instance variable type (2) can use generic module as instance variable type (2) - includes generic module with self (check argument superclass type, success) includes generic module with self (check argument superclass type, success) - finds inner class from inherited one (#476) finds inner class from inherited one (#476) - can use generic module as instance variable type can use generic module as instance variable type - errors when extending generic module that defines instance vars errors when extending generic module that defines instance vars - works ok in a case where a typed-def type has an underlying type that has an included generic module (bug) works ok in a case where a typed-def type has an underlying type that has an included generic module (bug) - gives error when including self gives error when including self - includes generic module with self (check return subclass type, success) includes generic module with self (check return subclass type, success) - gives helpful error message when generic type var is missing in block spec gives helpful error message when generic type var is missing in block spec - gives error with cyclic include between non-generic and generic module (2) gives error with cyclic include between non-generic and generic module (2) - initializes variable in module, recursive initializes variable in module, recursive - calls super on included generic module calls super on included generic module - types pointer of module with generic type types pointer of module with generic type - finds nested type inside method in block inside module finds nested type inside method in block inside module - can restrict module with module (#3029) can restrict module with module (#3029) - includes generic module with self (check argument superclass type, success) includes generic module with self (check argument superclass type, success) - finds in module when included finds in module when included - includes generic module and errors in call includes generic module and errors in call - includes generic module with self (check return type, success) includes generic module with self (check return type, success) - errors if declares module inside if errors if declares module inside if - correctly types type var in included module, with a restriction with a free var (bug) correctly types type var in included module, with a restriction with a free var (bug) - gives error when including self, generic module gives error when including self, generic module - finds class method in block finds class method in block - works with range and map works with range and map - errors when extending module that defines instance vars (2) (#4065) errors when extending module that defines instance vars (2) (#4065) - doesn't look up initialize past module that defines initialize (#7007) doesn't look up initialize past module that defines initialize (#7007) - calls super on included generic module and finds type var calls super on included generic module and finds type var - types pointer of module with method with two including types types pointer of module with method with two including types - errors if reopening generic module with different splat index errors if reopening generic module with different splat index - extends self extends self - includes generic module with self includes generic module with self - gives error with cyclic include, generic module gives error with cyclic include, generic module - finds types close to included module finds types close to included module - uses :Module name for modules in errors uses :Module name for modules in errors - gives error when trying to instantiate with new gives error when trying to instantiate with new - declares module automatically if not previously declared when declaring a module declares module automatically if not previously declared when declaring a module - inherits instance var type annotation from generic to concrete with T inherits instance var type annotation from generic to concrete with T - types proc of module with generic class types proc of module with generic class - errors when extending self and self defines instance vars (2) (#9568) errors when extending self and self defines instance vars (2) (#9568) - doesn't lookup type in ancestor when matches in current type (#2982) doesn't lookup type in ancestor when matches in current type (#2982) - types proc of module after type changes types proc of module after type changes - inherits instance var type annotation from generic to concrete inherits instance var type annotation from generic to concrete - errors if reopening generic module with different splat index (3) errors if reopening generic module with different splat index (3) - errors when recursively extending module that defines instance vars (2) errors when recursively extending module that defines instance vars (2) - includes generic module with self (check argument type, error) includes generic module with self (check argument type, error) - errors if reopening generic module with different type vars errors if reopening generic module with different type vars - includes generic module with type includes generic module with type - includes module with Union(T*) includes module with Union(T*) - includes module but not generic includes module but not generic - includes generic module with another generic type includes generic module with another generic type - type def does not reopen type from parent namespace (#11181) type def does not reopen type from parent namespace (#11181) - can't reopen as class can't reopen as class - can't pass module class to virtual metaclass (#6113) can't pass module class to virtual metaclass (#6113) - works with int including enumerable works with int including enumerable - gives helpful error message when generic type var is missing gives helpful error message when generic type var is missing - errors if including generic module and not specifying type vars errors if including generic module and not specifying type vars - errors when extending module that defines instance vars (#4065) errors when extending module that defines instance vars (#4065) - finds constant in generic module included in another module finds constant in generic module included in another module - gives error when including instantiation of self, generic module gives error when including instantiation of self, generic module - errors if reopening generic module with different type vars (2) errors if reopening generic module with different type vars (2) - instantiates generic variadic module, accesses T from instance method, more args instantiates generic variadic module, accesses T from instance method, more args - initializes variable in module initializes variable in module - includes generic module explicitly includes generic module explicitly - can instantiate generic module can instantiate generic module - extends module from generic class and calls class method (#7167) extends module from generic class and calls class method (#7167) - uses type declaration inside module and gives error uses type declaration inside module and gives error - types union of module and class that includes it types union of module and class that includes it - includes generic module with self (check return type, error) includes generic module with self (check return type, error) - types pointer of module with method types pointer of module with method - instantiates generic variadic module, accesses T from class method instantiates generic variadic module, accesses T from class method - errors when extending generic module that defines instance vars (2) errors when extending generic module that defines instance vars (2) - gives error with cyclic include gives error with cyclic include - errors if reopening generic module with different splat index (2) errors if reopening generic module with different splat index (2) - includes generic module explicitly and errors includes generic module explicitly and errors - extends generic module from generic class and calls class method (#7167) extends generic module from generic class and calls class method (#7167) - errors when extending self and self defines instance vars (3) (#9568) errors when extending self and self defines instance vars (3) (#9568) - uses type declaration inside module uses type declaration inside module - includes module in a class includes module in a class - types pointer of module with generic type types pointer of module with generic type - includes generic module with self, and inherits it includes generic module with self, and inherits it - extends generic module from generic module and calls class method (#7167) extends generic module from generic module and calls class method (#7167) - instantiates generic variadic module, accesses T from instance method through generic include instantiates generic variadic module, accesses T from instance method through generic include - gives error with cyclic include between non-generic and generic module gives error with cyclic include between non-generic and generic module - includes generic module with self (check return subclass type, error) includes generic module with self (check return subclass type, error) - can't reopen as struct can't reopen as struct - gives error when trying to instantiate with allocate gives error when trying to instantiate with allocate - includes but not a module includes but not a module - declares module automatically if not previously declared when declaring a class declares module automatically if not previously declared when declaring a class - errors if reopening non-generic module as generic errors if reopening non-generic module as generic - instantiates generic variadic module, accesses T from class method through generic extend instantiates generic variadic module, accesses T from class method through generic extend - extends a module extends a module - includes module in a module includes module in a module - uses type declaration inside module, recursive, and gives error uses type declaration inside module, recursive, and gives error - includes module but can't access metaclass methods includes module but can't access metaclass methods - includes module but wrong number of arguments includes module but wrong number of arguments - reports can't use instance variables inside module reports can't use instance variables inside module - inherits instance var type annotation from generic to generic to concrete inherits instance var type annotation from generic to generic to concrete -Code gen: method_missing - does method_missing macro with block does method_missing macro with block - finds method_missing with 'with ... yield' finds method_missing with 'with ... yield' - does method_missing macro with virtual type (4) does method_missing macro with virtual type (4) - does method_missing macro without args (with call) does method_missing macro without args (with call) - does method_missing macro with args does method_missing macro with args - does method_missing macro with virtual type (5) does method_missing macro with virtual type (5) - does method_missing macro with virtual type (7) does method_missing macro with virtual type (7) - does method_missing macro with virtual type (6) does method_missing macro with virtual type (6) - does method_missing macro with top level method involved does method_missing macro with top level method involved - does method_missing macro with args (with call) does method_missing macro with args (with call) - does method_missing macro with virtual type (8) does method_missing macro with virtual type (8) - does method_missing macro with virtual type (3) does method_missing macro with virtual type (3) - does method_missing macro with included module does method_missing macro with included module - works with named arguments that aren't legal variable names (#10381) works with named arguments that aren't legal variable names (#10381) - does method_missing generating method does method_missing generating method - does method_missing with assignment (bug) does method_missing with assignment (bug) - does method_missing macro with module involved does method_missing macro with module involved - does method_missing macro without args does method_missing macro without args - works with named arguments (#3654) works with named arguments (#3654) - does method_missing macro with virtual type (1) does method_missing macro with virtual type (1) - forwards forwards - does method_missing macro with virtual type (2) does method_missing macro with virtual type (2) - does method_missing macro with block but not using it does method_missing macro with block but not using it - does method_missing with assignment (2) (bug) does method_missing with assignment (2) (bug) -Crystal::Playground::AgentInstrumentorTransformer - instrument literals instrument literals - instrument ivar with obj instrument ivar with obj - instrument typeof instrument typeof - instrument single variables expressions instrument single variables expressions - instrument unless statement instrument unless statement - instrument is_a? expressions instrument is_a? expressions - instrument nested blocks unless in same line instrument nested blocks unless in same line - allow visibility modifiers allow visibility modifiers - instrument case statement instrument case statement - instrument multi statement def instrument multi statement def - do not instrument constants assignments do not instrument constants assignments - instrument assignments in the rhs instrument assignments in the rhs - instrument instance variable and class variables reads and writes instrument instance variable and class variables reads and writes - instrument puts with args instrument puts with args - instrument single statement def instrument single statement def - instrument not expressions instrument not expressions - instrument unary expressions instrument unary expressions - instrument exceptions instrument exceptions - do not instrument macro calls in class do not instrument macro calls in class - do not instrument class/module declared macro do not instrument class/module declared macro - instrument blocks and but non multi yields instrument blocks and but non multi yields - instrument nested class defs instrument nested class defs - do not instrument records class do not instrument records class - instrument single statement var def instrument single statement var def - do not instrument class initializing arguments do not instrument class initializing arguments - instrument chained comparisons (#4663) instrument chained comparisons (#4663) - instrument print with args instrument print with args - instrument if statement instrument if statement - instrument string interpolations instrument string interpolations - do not instrument top level macro calls do not instrument top level macro calls - instrument literals with expression names instrument literals with expression names - instrument while statement instrument while statement - instrument class defs instrument class defs - instrument inside modules instrument inside modules - instrument multi assignments in the rhs instrument multi assignments in the rhs - instrument returns inside def instrument returns inside def - instrument binary expressions instrument binary expressions - instrument blocks and single yields instrument blocks and single yields -Semantic: lib - errors if assigning void lib call to var (#4414) errors if assigning void lib call to var (#4414) - raises on undefined fun raises on undefined fun - errors if missing arguments errors if missing arguments - errors if lib fun call is part of dispatch errors if lib fun call is part of dispatch - errors if parameter already specified errors if parameter already specified - error if passing non primitive type as varargs error if passing non primitive type as varargs - passes float as another integer type in variable passes float as another integer type in variable - passes int as another integer type with literal passes int as another integer type with literal - allows passing splat to LibC fun allows passing splat to LibC fun - defined fun with aliased type defined fun with aliased type - reports redefinition of fun with different signature reports redefinition of fun with different signature - error if passing type to LibC with to_unsafe but type doesn't match error if passing type to LibC with to_unsafe but type doesn't match - errors if fourth argument is not a bool errors if fourth argument is not a bool - overrides definition of fun overrides definition of fun - errors if second argument is not a string errors if second argument is not a string - reports error when changing instance var type and something breaks reports error when changing instance var type and something breaks - reports error on fun argument type not primitive like reports error on fun argument type not primitive like - allows passing double splat to LibC fun allows passing double splat to LibC fun - raises wrong number of arguments raises wrong number of arguments - reports error out can only be used with lib funs in named argument reports error out can only be used with lib funs in named argument - types fun returning nothing as nil types fun returning nothing as nil - allows invoking out with underscore allows invoking out with underscore - errors if invoking to_i32! and got error in that call errors if invoking to_i32! and got error in that call - errors if lib already specified with positional argument errors if lib already specified with positional argument - correctly attached link flags if there's a macro if correctly attached link flags if there's a macro if - types a varargs external types a varargs external - disallows passing nil or pointer to arg expecting pointer disallows passing nil or pointer to arg expecting pointer - errors if unknown named arg errors if unknown named arg - errors if using void as parameter (related to #508) errors if using void as parameter (related to #508) - gathers link annotations from macro expression gathers link annotations from macro expression - reopens lib and adds same link annotations reopens lib and adds same link annotations - allows dll argument allows dll argument - reopens lib and adds more link annotations reopens lib and adds more link annotations - specifies a call convention specifies a call convention + finds yielding methods finds yielding methods + finds methods called from reachable code finds methods called from reachable code + finds method called from instance variable initializer finds method called from instance variable initializer + finds method in abstract type finds method in abstract type + finds methods with proc parameter finds methods with proc parameter + finds method with free variable finds method with free variable + finds methods in generic type finds methods in generic type +Code gen: experimental + errors if too many arguments errors if too many arguments + compiles with single string argument compiles with single string argument errors if missing link arguments errors if missing link arguments - errors if using out with non-pointer errors if using out with non-pointer - errors if CallConvention argument is not a string errors if CallConvention argument is not a string - errors if CallConvention argument is not a valid string errors if CallConvention argument is not a valid string - reports error on fun argument type not primitive like, Nil (#2994) reports error on fun argument type not primitive like, Nil (#2994) - errors if defining incompatible funs with the same name in the same lib (#3045) errors if defining incompatible funs with the same name in the same lib (#3045) - errors if missing argument errors if missing argument - passes int as another integer type in variable passes int as another integer type in variable - can use macros inside lib can use macros inside lib - error if passing non primitive type as varargs invoking to_unsafe error if passing non primitive type as varargs invoking to_unsafe - reports error if using out with an already declared variable reports error if using out with an already declared variable - raises wrong argument type raises wrong argument type - types lib var set types lib var set - types fun returning void as nil types fun returning void as nil - reports error out can only be used with lib funs reports error out can only be used with lib funs - warns if @[Link(static: true)] is specified warns if @[Link(static: true)] is specified - errors if too many link arguments errors if too many link arguments - errors if using out with void pointer (#2424) errors if using out with void pointer (#2424) - errors if redefining fun with different signature (#2468) errors if redefining fun with different signature (#2468) - clears annotations after lib clears annotations after lib - types fun returning nil as nil types fun returning nil as nil - warns if Link annotations use positional arguments warns if Link annotations use positional arguments - reports error on struct field type not primitive like reports error on struct field type not primitive like - errors if using void via typedef as parameter (related to #508) errors if using void via typedef as parameter (related to #508) - errors if defining incompatible funs with the same name in different libs (#3045) errors if defining incompatible funs with the same name in different libs (#3045) - supports forward references with struct inside struct (#399) supports forward references with struct inside struct (#399) - errors if defines def on lib errors if defines def on lib - types lib var get with forward declaration types lib var get with forward declaration - errors if using out with void pointer through type errors if using out with void pointer through type - can use out with named args can use out with named args - supports forward references (#399) supports forward references (#399) - reports error on fun return type not primitive like reports error on fun return type not primitive like - defines lib funs before funs with body defines lib funs before funs with body - errors if wrong number of arguments for CallConvention errors if wrong number of arguments for CallConvention - errors if dll argument does not end with '.dll' errors if dll argument does not end with '.dll' - errors if passing void lib call to call argument (#4414) errors if passing void lib call to call argument (#4414) - specifies a call convention to a lib specifies a call convention to a lib - types lib var get types lib var get - reports error on typedef type not primitive like reports error on typedef type not primitive like - reports error when changing var type and something breaks reports error when changing var type and something breaks - can use tuple as fun return can use tuple as fun return - can use macros inside struct can use macros inside struct - errors if first argument is not a string errors if first argument is not a string - errors if dll argument contains directory separators errors if dll argument contains directory separators - errors if using named args with variadic function errors if using named args with variadic function - can list lib functions at the top level (#12395) can list lib functions at the top level (#12395) - doesn't try to invoke unsafe for c struct/union (#1362) doesn't try to invoke unsafe for c struct/union (#1362) - errors if third argument is not a bool errors if third argument is not a bool - errors if using unknown named param errors if using unknown named param - errors if using out with varargs errors if using out with varargs - errors if invoking to_i32! and got wrong type errors if invoking to_i32! and got wrong type - errors if lib named arg is not a String errors if lib named arg is not a String - can use named args can use named args - allows invoking lib call without obj inside lib allows invoking lib call without obj inside lib + compiles with no argument compiles with no argument + errors if invalid argument type errors if invalid argument type Crystal::Repl::Interpreter - pointers - interprets pointer set and get (int) interprets pointer set and get (int) - pointerof instance var pointerof instance var - interprets pointerof, mutates var, read pointer interprets pointerof, mutates var, read pointer - pointerof class var pointerof class var - interprets nilable pointer truthiness interprets nilable pointer truthiness - discards pointer malloc discards pointer malloc - interprets pointerof and mutates memory (there are more variables) interprets pointerof and mutates memory (there are more variables) - interprets pointerof, mutates pointer, read var interprets pointerof, mutates pointer, read var - discards pointer add discards pointer add - interprets pointer diff, negative interprets pointer diff, negative - interprets pointer set and get (clear stack) interprets pointer set and get (clear stack) - pointerof read `StaticArray#@buffer` (2) pointerof read `StaticArray#@buffer` (2) - pointerof read `StaticArray#@buffer` (1) pointerof read `StaticArray#@buffer` (1) - interprets pointer add interprets pointer add - interprets pointer new and pointer address interprets pointer new and pointer address - interprets pointer set and get (union type, setter value) interprets pointer set and get (union type, setter value) - interprets pointer diff interprets pointer diff - interprets pointer set and get (bool) interprets pointer set and get (bool) - discards pointerof discards pointerof - pointerof read instance var pointerof read instance var - discards pointer diff discards pointer diff - discards pointer set discards pointer set - discards pointer get discards pointer get - interprets pointer set and get (union type) interprets pointer set and get (union type) - discards pointer new discards pointer new - interprets pointer realloc wrapper interprets pointer realloc wrapper - discards pointer realloc discards pointer realloc - interprets pointer realloc interprets pointer realloc -Codegen: special vars - preserves special vars in macro expansion with call with default arguments (#824) preserves special vars in macro expansion with call with default arguments (#824) - codegens after block 2 codegens after block 2 - codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block codegens after block - codegens $~ codegens $~ - codegens $? codegens $? - codegens with default argument codegens with default argument - codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) codegens $~ with nilable (1) - codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) codegens $? with nilable (1) - codegens $~ two levels codegens $~ two levels - allows with struct allows with struct - allows with primitive allows with primitive - preserves special vars if initialized inside block (#2194) preserves special vars if initialized inside block (#2194) - codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) codegens $~ with nilable (2) - codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) codegens $? with nilable (2) - codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block codegens in block with nested block - codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block codegens in block - works lazily works lazily works lazily works lazily works lazily works lazily works lazily works lazily works lazily works lazily -semantic: case - checks exhaustiveness of union with bool checks exhaustiveness of union with bool - checks exhaustiveness of enum combined with another type checks exhaustiveness of enum combined with another type - can prove case is exhaustive for @[Flags] enum when matching type can prove case is exhaustive for @[Flags] enum when matching type - checks exhaustiveness of single type checks exhaustiveness of single type - checks exhaustiveness of bool type (missing false) checks exhaustiveness of bool type (missing false) - checks exhaustiveness of bool type with other types checks exhaustiveness of bool type with other types - checks exhaustiveness of enum through method (all cases covered) checks exhaustiveness of enum through method (all cases covered) - checks exhaustiveness for tuple literal of 3 elements, and warns checks exhaustiveness for tuple literal of 3 elements, and warns - checks exhaustiveness for tuple literal with bool and underscore at second position checks exhaustiveness for tuple literal with bool and underscore at second position - checks exhaustiveness for tuple literal with bool and underscore at second position checks exhaustiveness for tuple literal with bool and underscore at second position - covers all types covers all types - checks exhaustiveness of bool type (missing true) checks exhaustiveness of bool type (missing true) - checks exhaustiveness for tuple literal of 2 elements, first is enum checks exhaustiveness for tuple literal of 2 elements, first is enum - checks exhaustiveness for tuple literal with bool and underscore at first position checks exhaustiveness for tuple literal with bool and underscore at first position - checks exhaustiveness of union type with virtual type checks exhaustiveness of union type with virtual type - checks exhaustiveness for tuple literal with types and underscore at second position checks exhaustiveness for tuple literal with types and underscore at second position - doesn't check exhaustiveness when using 'when' doesn't check exhaustiveness when using 'when' - checks exhaustiveness, covers in base type covers checks exhaustiveness, covers in base type covers - can't prove case is exhaustive for @[Flags] enum can't prove case is exhaustive for @[Flags] enum - checks exhaustiveness of enum via question method checks exhaustiveness of enum via question method - checks exhaustiveness for tuple literal with bool and underscore at second position, with partial match checks exhaustiveness for tuple literal with bool and underscore at second position, with partial match - checks exhaustiveness of enum (all cases covered) checks exhaustiveness of enum (all cases covered) - can't prove case is exhaustive for @[Flags] enum, tuple case can't prove case is exhaustive for @[Flags] enum, tuple case - checks exhaustiveness of single type (T.class) checks exhaustiveness of single type (T.class) - checks exhaustiveness for tuple literal with bool and underscore at first position, partial match checks exhaustiveness for tuple literal with bool and underscore at first position, partial match - checks exhaustiveness for tuple literal with bool and underscore at first position, with partial match checks exhaustiveness for tuple literal with bool and underscore at first position, with partial match - checks exhaustiveness for tuple literal, and passes checks exhaustiveness for tuple literal, and passes - checks exhaustiveness of nilable type with nil literal checks exhaustiveness of nilable type with nil literal - checks exhaustiveness for tuple literal with bool and underscore at second position, partial match checks exhaustiveness for tuple literal with bool and underscore at second position, partial match - checks exhaustiveness, covers in base type covers (generic type) checks exhaustiveness, covers in base type covers (generic type) - checks exhaustiveness for tuple literal with types and underscore at first position checks exhaustiveness for tuple literal with types and underscore at first position - checks exhaustiveness for tuple literal, with call checks exhaustiveness for tuple literal, with call - checks exhaustiveness for tuple literal of 2 elements, and warns checks exhaustiveness for tuple literal of 2 elements, and warns - checks exhaustiveness for tuple literal of 2 elements, first is bool checks exhaustiveness for tuple literal of 2 elements, first is bool - checks exhaustiveness for tuple literal of 3 elements, all bool checks exhaustiveness for tuple literal of 3 elements, all bool - errors if casing against a constant errors if casing against a constant - checks exhaustiveness of enum via const checks exhaustiveness of enum via const - checks exhaustiveness for tuple literal with bool and underscore at first position checks exhaustiveness for tuple literal with bool and underscore at first position - checks exhaustiveness of single type (generic) checks exhaustiveness of single type (generic) - checks exhaustiveness for tuple literal of 3 elements, all enums checks exhaustiveness for tuple literal of 3 elements, all enums - checks exhaustiveness of single type (Foo(T).class) checks exhaustiveness of single type (Foo(T).class) - checks exhaustiveness of nil type with nil literal checks exhaustiveness of nil type with nil literal -Crystal - normalize_path - assert assert - assert assert - assert assert - assert assert -implementations - find const implementation find const implementation - find class defined by macro find class defined by macro - find module implementation find module implementation - find method calls inside while cond find method calls inside while cond - find method calls inside rescue find method calls inside rescue - find struct implementation find struct implementation - find implementation from macro expansions find implementation from macro expansions - find implementation inside contained file private method find implementation inside contained file private method - find implementation in generic class methods find implementation in generic class methods - find top level method calls find top level method calls - find method calls inside if find method calls inside if - find full trace for macro expansions find full trace for macro expansions - find class inside method find class inside method - find implementors of different classes find implementors of different classes - can display text output can display text output - can display json output can display json output - find implementation inside contained class' class method find implementation inside contained class' class method - find implementation in class methods find implementation in class methods - find method calls inside trailing if find method calls inside trailing if - find enum value implementation find enum value implementation - find enum implementation find enum implementation - find implementation inside a module class find implementation inside a module class - find class implementation find class implementation - find implementation inside contained file private class' class method find implementation inside contained file private class' class method - find implementors of classes that are only used find implementors of classes that are only used - find open class implementation find open class implementation - find alias implementation find alias implementation - find implementation in generic class find implementation in generic class - find method calls inside while find method calls inside while -.parse_args - DIR with path DIR with path - DIR (absolute) DIR (absolute) - DIR DIR - DIR (relative to home) DIR (relative to home) - NAME DIR NAME DIR - DIR = . DIR = . -Semantic: var - types an assign types an assign - declares local variable and then assigns it declares local variable and then assigns it - types an assign with type declaration types an assign with type declaration - errors if declaring generic type without type vars (with local var) errors if declaring generic type without type vars (with local var) - errors if reads from underscore errors if reads from underscore - reports variable always nil reports variable always nil - declares local variable and assigns wrong type declares local variable and assigns wrong type - declares local variable but doesn't assign it in all branches declares local variable but doesn't assign it in all branches - lets type on else side of if with a Bool | Nil union lets type on else side of if with a Bool | Nil union - errors if variable already exists errors if variable already exists - declares local variable with value declares local variable with value - reports there's no self reports there's no self - declares local variable and assigns it with if declares local variable and assigns it with if - errors if declaring var that is already declared errors if declaring var that is already declared - reports undefined local variable or method reports undefined local variable or method - parse local variable as method call even if local variable is declared in call arguments parse local variable as method call even if local variable is declared in call arguments - declares local variable and immediately reads it declares local variable and immediately reads it - types a variable types a variable -Codegen: super - codegens super inside closure forwarding args codegens super inside closure forwarding args - calls super in module method (#556) calls super in module method (#556) - calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) calls super in metaclass (#1522) - codegens super without arguments codegens super without arguments - codegens super inside closure codegens super inside closure - calls super from virtual metaclass type (#2841) calls super from virtual metaclass type (#2841) - codegens super that calls subclass method 3 codegens super that calls subclass method 3 - codegens super that calls subclass method codegens super that calls subclass method - codegens super that calls subclass method 5 codegens super that calls subclass method 5 - calls super in generic module method calls super in generic module method - codegens super that calls subclass method 6 codegens super that calls subclass method 6 - codegens super without arguments and instance variable codegens super without arguments and instance variable - doesn't invoke super twice in inherited generic types (#942) doesn't invoke super twice in inherited generic types (#942) - codegens super that calls subclass method 2 codegens super that calls subclass method 2 - calls super with dispatch (#2318) calls super with dispatch (#2318) - codegens super without arguments but parent has arguments codegens super without arguments but parent has arguments - calls super on an object (#10004) calls super on an object (#10004) - does super in virtual type including module does super in virtual type including module - build super on generic class (bug) build super on generic class (bug) - codegens super that calls subclass method 4 codegens super that calls subclass method 4 -Semantic: is_a? - applies filter inside block applies filter inside block - restricts type inside if scope 2 restricts type inside if scope 2 - restricts type inside if else when used with module type restricts type inside if else when used with module type - restricts other types inside if else restricts other types inside if else - checks union with union checks union with union - types if is_a? preceded by return if (preserves nops) types if is_a? preceded by return if (preserves nops) - restricts type inside if scope 3 restricts type inside if scope 3 - restricts in assignment restricts in assignment - does is_a? from virtual metaclass to generic metaclass (#12302) does is_a? from virtual metaclass to generic metaclass (#12302) - doesn't fail on untyped is_a (#10317) doesn't fail on untyped is_a (#10317) - is bool is bool - applies negative condition filter if then is no return applies negative condition filter if then is no return - restricts type in else but lazily restricts type in else but lazily - restricts type inside if scope 1 restricts type inside if scope 1 - checks simple type with union checks simple type with union -Semantic: exception - types a var after begin rescue as having all possible types in begin and rescue (2) types a var after begin rescue as having all possible types in begin and rescue (2) - can use break inside block inside ensure (#4470) can use break inside block inside ensure (#4470) - can't return from block inside ensure (#4470) can't return from block inside ensure (#4470) - marks fun as raises marks fun as raises - marks method calling method that raises as raises marks method calling method that raises as raises - can't return from while inside ensure (#4470) can't return from while inside ensure (#4470) - doesn't crash on break inside rescue, in while (#2441) doesn't crash on break inside rescue, in while (#2441) - errors if caught exception is a union but not all types are valid errors if caught exception is a union but not all types are valid - type is union of main and rescue blocks type is union of main and rescue blocks - types var as nilable inside ensure (1) types var as nilable inside ensure (1) - remains nilable after rescue remains nilable after rescue - doesn't consider vars as nilable inside else (#610) doesn't consider vars as nilable inside else (#610) - marks method that calls another method that raises as raises, recursively marks method that calls another method that raises as raises, recursively - types a var after begin rescue as having all possible types in begin and rescue types a var after begin rescue as having all possible types in begin and rescue - shadows local variable (1) shadows local variable (1) - doesn't type instance variable as nilable if assigned inside an exception handler after being assigned doesn't type instance variable as nilable if assigned inside an exception handler after being assigned - types a var after rescue as being nilable types a var after rescue as being nilable - can't use next inside block inside ensure (#4470) can't use next inside block inside ensure (#4470) - marks def as raises marks def as raises - can use next inside block inside ensure (#4470) can use next inside block inside ensure (#4470) - type union with empty rescue block type union with empty rescue block - can't use break inside block inside ensure (#4470) can't use break inside block inside ensure (#4470) - types a var after begin rescue as having all possible types and nil in begin if read (2) types a var after begin rescue as having all possible types and nil in begin if read (2) - marks proc literal as raises marks proc literal as raises - marks method calling lib fun that raises as raises marks method calling lib fun that raises as raises - transform nodes in else block transform nodes in else block - detects reading nil-if-read variable after exception handler (#4723) detects reading nil-if-read variable after exception handler (#4723) - types instance variable as nilable if assigned inside an exception handler (#1845) types instance variable as nilable if assigned inside an exception handler (#1845) - errors if caught exception is not a subclass of Exception without var errors if caught exception is not a subclass of Exception without var - types exception var with no types types exception var with no types - correctly types variable assigned inside nested exception handler (#9769) correctly types variable assigned inside nested exception handler (#9769) - types exception with type types exception with type - can't return from ensure (#4470) can't return from ensure (#4470) - marks instance variable as nilable if assigned inside rescue inside initialize marks instance variable as nilable if assigned inside rescue inside initialize - says syntax error on "begin; rescue ex; rescue ex : Foo; end; ex" says syntax error on "begin; rescue ex; rescue ex : Foo; end; ex" - can't use break inside while inside ensure (#4470) can't use break inside while inside ensure (#4470) - types var assignment inside block inside exception handler (#3324) types var assignment inside block inside exception handler (#3324) - assigns var inside ensure (1) (#3919) assigns var inside ensure (1) (#3919) - type for exception handler for explicit types type for exception handler for explicit types - errors if caught exception is a nested union but not all types are valid errors if caught exception is a nested union but not all types are valid - says syntax error on "begin; rescue ex; rescue; end; ex" says syntax error on "begin; rescue ex; rescue; end; ex" - doesn't infect type to variable before handler (#4002) doesn't infect type to variable before handler (#4002) - assigns var inside ensure (2) (#3919) assigns var inside ensure (2) (#3919) - types var as nilable inside ensure (2) types var as nilable inside ensure (2) - errors if caught exception is not a subclass of Exception errors if caught exception is not a subclass of Exception - types var as nilable if previously nilable (2) types var as nilable if previously nilable (2) - can use break inside while inside ensure (#4470) can use break inside while inside ensure (#4470) - says syntax error on "begin; else; 1; end" says syntax error on "begin; else; 1; end" - types a var after begin rescue with no-return in rescue types a var after begin rescue with no-return in rescue - types code with abstract exception that delegates method types code with abstract exception that delegates method - types var as nilable if previously nilable (1) types var as nilable if previously nilable (1) - can use next inside while inside ensure (#4470) can use next inside while inside ensure (#4470) - type union with empty main block type union with empty main block - correctly types variables inside conditional inside exception handler with no-return rescue (#8012) correctly types variables inside conditional inside exception handler with no-return rescue (#8012) - can't use next inside while inside ensure (#4470) can't use next inside while inside ensure (#4470) - correctly types #1988 correctly types #1988 - gets a non-nilable type if all rescue are unreachable (#8751) gets a non-nilable type if all rescue are unreachable (#8751) - types var as not nil if defined inside begin and defined inside rescue types var as not nil if defined inside begin and defined inside rescue -Code gen: offsetof - returns offset allowing manual access of first struct field returns offset allowing manual access of first struct field - returns offset of extern union returns offset of extern union - returns offset allowing manual access of tuple items returns offset allowing manual access of tuple items - returns offset allowing manual access of first class field returns offset allowing manual access of first class field - returns offset of `StaticArray#@buffer` returns offset of `StaticArray#@buffer` - returns offset allowing manual access of struct field that isn't first returns offset allowing manual access of struct field that isn't first - returns offset allowing manual access of class field that isn't first returns offset allowing manual access of class field that isn't first -Code gen: virtual type - lookup instance variables in parent types lookup instance variables in parent types - can belong to union can belong to union - initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated initializes ivars to nil even if object never instantiated - codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type codegens new for virtual class with one type - assign instance variable in virtual type assign instance variable in virtual type - dispatches on virtual metaclass (1) dispatches on virtual metaclass (1) - call base method call base method - codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types codegens new for virtual class with two types - codegens new twice for virtual codegens new twice for virtual - casts union to virtual casts union to virtual - dispatch call with nilable virtual arg dispatch call with nilable virtual arg - codegens allocate for virtual type with custom new codegens allocate for virtual type with custom new - codegens virtual call with explicit self and nilable type codegens virtual call with explicit self and nilable type - casts virtual type to union casts virtual type to union - codegens non-virtual call that calls virtual call to another virtual call codegens non-virtual call that calls virtual call to another virtual call - calls class method 2 calls class method 2 - dispatches on virtual metaclass (2) dispatches on virtual metaclass (2) - codegens virtual call with explicit self codegens virtual call with explicit self - call overwritten method call overwritten method - codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type codegens call to Object#to_s from virtual type - casts virtual type to base virtual type casts virtual type to base virtual type - doesn't lookup in Value+ when virtual type is Object+ doesn't lookup in Value+ when virtual type is Object+ - codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) codegens new for new on virtual abstract class (#3835) - dispatch call with virtual type argument dispatch call with virtual type argument - call base overwritten method call base overwritten method - codegens virtual method of abstract metaclass codegens virtual method of abstract metaclass - calls class method 1 calls class method 1 - codegens new for simple type, then for virtual codegens new for simple type, then for virtual - casts metaclass union type to virtual metaclass type (#6298) casts metaclass union type to virtual metaclass type (#6298) - calls class method 3 calls class method 3 - codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type codegens call to Object#to_s from nilable type - correctly dispatch call with block when the obj is a virtual type correctly dispatch call with block when the obj is a virtual type - returns type with virtual type def type returns type with virtual type def type - dispatches on virtual metaclass (3) dispatches on virtual metaclass (3) -Crystal::Doc::Generator - .anchor_link - generates the correct anchor link generates the correct anchor link -Crystal::Doc::Generator - crystal repo - inserts pseudo methods inserts pseudo methods - #collect_constants - returns empty array when constants are private returns empty array when constants are private - #formatted_doc - with a Experimental annotation, and docs - should generate both the docs and Experimental tag should generate both the docs and Experimental tag - with a Deprecated annotation, and no docs - should generate just the Deprecated tag should generate just the Deprecated tag - with no annotation, and no docs - should generate nothing should generate nothing - should generate the full document should generate the full document - with a Experimental annotation, and no docs - should generate just the Experimental tag should generate just the Experimental tag - should generate the full document should generate the full document - with a Deprecated annotation, and docs - should generate both the docs and Deprecated tag should generate both the docs and Deprecated tag - #formatted_summary - should generate the first line should generate the first line - with a Deprecated annotation, and no docs - should generate just the Deprecated tag should generate just the Deprecated tag - should generate the first sentence should generate the first sentence - with a Deprecated annotation, and docs - should generate both the docs and Deprecated tag should generate both the docs and Deprecated tag - should exclude whitespace before the summary line should exclude whitespace before the summary line - with a Experimental annotation, and no docs - should generate just the Experimental tag should generate just the Experimental tag - with no annotation, and no docs - should generate nothing should generate nothing - with a Experimental annotation, and docs - should generate both the docs and Experimental tag should generate both the docs and Experimental tag - generates sitemap generates sitemap - #must_include_toplevel? - returns false if program has constant which is defined in other place returns false if program has constant which is defined in other place - returns false if program has nothing returns false if program has nothing - returns false if program has macro which is defined in other place returns false if program has macro which is defined in other place - returns true if program has constant returns true if program has constant - returns true if program has macro returns true if program has macro - returns true if program has method returns true if program has method - returns false if program has method which is defined in other place returns false if program has method which is defined in other place + structs + does call receiver by value from VirtualType abstract struct to union does call receiver by value from VirtualType abstract struct to union + does constructor does constructor + discards allocate discards allocate + does allocate, set instance var and get instance var does allocate, set instance var and get instance var + mutates struct inside union mutates struct inside union + interprets read instance var of struct interprets read instance var of struct + inlines struct method that returns self (#12253) inlines struct method that returns self (#12253) + does complex class instance var initializer does complex class instance var initializer + does simple class instance var initializer does simple class instance var initializer + does class instance var initializer inheritance does class instance var initializer inheritance + does call receiver by value from VirtualType abstract struct to concrete struct (#12190) does call receiver by value from VirtualType abstract struct to concrete struct (#12190) + sets multiple instance vars in virtual abstract struct call (#12187) sets multiple instance vars in virtual abstract struct call (#12187) + does simple struct instance var initializer does simple struct instance var initializer + mutates struct stored in class var mutates struct stored in class var + casts def body to def type casts def body to def type +Codegen: private + doesn't include filename for private types doesn't include filename for private types + codegens private def in same file codegens private def in same file + codegens class vars of private types with same name (#11620) codegens class vars of private types with same name (#11620) + codegens class var of private type with same name as public type (#11620) codegens class var of private type with same name as public type (#11620) + codegens overloaded private def in same file codegens overloaded private def in same file Semantic: const - errors if using const in var declaration errors if using const in var declaration - errors if using const in proc notation parameter type errors if using const in proc notation parameter type - can use constant defined later (#2906) can use constant defined later (#2906) + types a nested constant types a nested constant + finds current type only for first path item (2) finds current type only for first path item (2) + types a nested type with same name types a nested type with same name + doesn't error if using c enum doesn't error if using c enum doesn't errors if constant depends on another one defined later through method, but constant is simple (~ 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (~ 2) - doesn't count parent types as current type doesn't count parent types as current type - doesn't errors if constant depends on another one defined later through method, but constant is simple (true) doesn't errors if constant depends on another one defined later through method, but constant is simple (true) + errors on dynamic constant assignment inside block errors on dynamic constant assignment inside block + doesn't errors if constant depends on another one defined later through method, but constant is simple (- 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (- 2) + doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &- 1) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &- 1) + errors if using const in proc notation parameter type errors if using const in proc notation parameter type + types a constant using Path types a constant using Path errors if constant has NoReturn type (#6139) errors if constant has NoReturn type (#6139) + doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED - 1) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED - 1) + doesn't errors if constant depends on another one defined later through method, but constant is simple (1 + ZED) doesn't errors if constant depends on another one defined later through method, but constant is simple (1 + ZED) + errors if using const in restriction errors if using const in restriction + creates container module if not exist when using Path creates container module if not exist when using Path + finds current type before parents (#4086) finds current type before parents (#4086) finds current type first finds current type first - errors if using constant as generic type (#3240) errors if using constant as generic type (#3240) + types a nested constant using Path types a nested constant using Path + doesn't errors if constant depends on another one defined later through method, but constant is simple (+ 1) doesn't errors if constant depends on another one defined later through method, but constant is simple (+ 1) errors if can't infer constant type (#3240, #3948) errors if can't infer constant type (#3240, #3948) + doesn't crash with const used in initialize (bug) doesn't crash with const used in initialize (bug) + doesn't count parent types as current type doesn't count parent types as current type + finds nearest constant first finds nearest constant first + doesn't errors if constant depends on another one defined later through method, but constant is simple (true) doesn't errors if constant depends on another one defined later through method, but constant is simple (true) + doesn't errors if constant depends on another one defined later through method, but constant is simple (1) doesn't errors if constant depends on another one defined later through method, but constant is simple (1) + errors if using const in type declaration errors if using const in type declaration types a constant reference types a constant reference - errors on dynamic constant assignment inside if errors on dynamic constant assignment inside if - doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &* 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &* 2) - doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED - 1) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED - 1) errors if using const in uninitialized errors if using const in uninitialized + doesn't errors if constant depends on another one defined later through method, but constant is simple (1 &+ ZED) doesn't errors if constant depends on another one defined later through method, but constant is simple (1 &+ ZED) + finds constant in module that includes module (#205) finds constant in module that includes module (#205) doesn't errors if constant depends on another one defined later through method, but constant is simple (1 + 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (1 + 2) - doesn't errors if constant depends on another one defined later through method, but constant is simple ('a') doesn't errors if constant depends on another one defined later through method, but constant is simple ('a') - finds current type only for first path item (2) finds current type only for first path item (2) - finds constant in class that extends class (#205) finds constant in class that extends class (#205) - errors if using return inside constant value (#5391) errors if using return inside constant value (#5391) - doesn't errors if constant depends on another one defined later through method, but constant is simple (1) doesn't errors if constant depends on another one defined later through method, but constant is simple (1) - finds nearest constant first finds nearest constant first - types a constant types a constant - keeps type of container when using Path keeps type of container when using Path - doesn't errors if constant depends on another one defined later through method, but constant is simple (- 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (- 2) - doesn't crash with const used in initialize (bug) doesn't crash with const used in initialize (bug) - doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED // 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED // 2) - doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &- 1) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &- 1) - errors if using const in restriction errors if using const in restriction - types a nested type with same name types a nested type with same name - types a nested constant using Path types a nested constant using Path - types a constant using Path types a constant using Path - doesn't errors if constant depends on another one defined later through method, but constant is simple (nil) doesn't errors if constant depends on another one defined later through method, but constant is simple (nil) - doesn't errors if constant depends on another one defined later through method, but constant is simple (+ 1) doesn't errors if constant depends on another one defined later through method, but constant is simple (+ 1) - finds current type only for first path item (1) finds current type only for first path item (1) - types a nested constant types a nested constant - finds const from restriction finds const from restriction + doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &* 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED &* 2) doesn't errors if constant depends on another one defined later through method, but constant is simple ("foo") doesn't errors if constant depends on another one defined later through method, but constant is simple ("foo") - creates container module if not exist when using Path creates container module if not exist when using Path - doesn't error if using c enum doesn't error if using c enum + doesn't errors if constant depends on another one defined later through method, but constant is simple (nil) doesn't errors if constant depends on another one defined later through method, but constant is simple (nil) + doesn't errors if constant depends on another one defined later through method, but constant is simple ('a') doesn't errors if constant depends on another one defined later through method, but constant is simple ('a') doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED * 2) doesn't errors if constant depends on another one defined later through method, but constant is simple (ZED * 2) - doesn't errors if constant depends on another one defined later through method, but constant is simple (1 + ZED) doesn't errors if constant depends on another one defined later through method, but constant is simple (1 + ZED) - doesn't share variables with global scope doesn't share variables with global scope - errors on dynamic constant assignment inside block errors on dynamic constant assignment inside block types a global constant reference in method types a global constant reference in method + can use constant defined later (#2906) can use constant defined later (#2906) types a global constant reference in static method types a global constant reference in static method - errors if using const in proc notation return type errors if using const in proc notation return type - doesn't errors if constant depends on another one defined later through method, but constant is simple (1 &+ ZED) doesn't errors if constant depends on another one defined later through method, but constant is simple (1 &+ ZED) - errors if using const in type declaration errors if using const in type declaration - finds current type before parents (#4086) finds current type before parents (#4086) - finds constant in module that includes module (#205) finds constant in module that includes module (#205) types a constant inside a def types a constant inside a def -error reporting - reports wrong number of arguments reports wrong number of arguments - reports wrong number of arguments, with optional parameters reports wrong number of arguments, with optional parameters - reports missing block reports missing block - reports unexpected named argument (2) reports unexpected named argument (2) - reports unexpected block reports unexpected block - reports unexpected named argument reports unexpected named argument - uses correct name for top-level macro methods uses correct name for top-level macro methods -Code gen: cast - allows casting nil to Void* allows casting nil to Void* - codegens class method when type id is available but not a virtual type (#3490) codegens class method when type id is available but not a virtual type (#3490) - downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment downcasts from union to union with different alignment - casts between union types, where union has a tuple type (#3377) casts between union types, where union has a tuple type (#3377) - casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) casts from nilable type to virtual type (#3512) - casts with block var that changes type (#3341) casts with block var that changes type (#3341) - doesn't corrupt stack when downcasting union to union with different alignment (#14285) doesn't corrupt stack when downcasting union to union with different alignment (#14285) - casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil casts from nilable to nil - casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) casts (bug) - casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError casts from union to another union raises TypeCastError - casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union casts from union to another union - casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type casts from virtual to single type - sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment sidecasts from union to union with different alignment - casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError casts from virtual to single type raises TypeCastError - can cast from Void* to virtual type (#3014) can cast from Void* to virtual type (#3014) - casts to module casts to module casts to module casts to module casts to module casts to module casts to module casts to module casts to module casts to module - allows casting nilable type to Void* (3) allows casting nilable type to Void* (3) - casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int casts from int to int - upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment upcasts from union to union with different alignment - casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type casts from union to single type - allows casting object to pointer and back allows casting object to pointer and back - allows casting nilable type to Void* (2) allows casting nilable type to Void* (2) - cast virtual metaclass type to nilable virtual instance type (#12628) cast virtual metaclass type to nilable virtual instance type (#12628) - casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError casts from nilable to nil raises TypeCastError - casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer casts from pointer to pointer - allows casting nilable type to Void* (1) allows casting nilable type to Void* (1) - upcasts type to virtual (#3304) upcasts type to virtual (#3304) - upcasts from non-generic to generic upcasts from non-generic to generic - casts to base class making it virtual casts to base class making it virtual - casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError casts from union to single type raises TypeCastError - can cast to metaclass (#11121) can cast to metaclass (#11121) - upcasts type to virtual (2) (#3304) upcasts type to virtual (2) (#3304) - casts to bigger union casts to bigger union -Crystal::Codegen::Target - normalizes triples normalizes triples - parses incomplete triples parses incomplete triples - parses freebsd version parses freebsd version -Code gen: not - doesn't crash doesn't crash - codegens not pointer (false) codegens not pointer (false) - codegens not number codegens not number - codegens not pointer (true) codegens not pointer (true) - codegens not nilable type (true) codegens not nilable type (true) - codegens not with inlinable value (#6451) codegens not with inlinable value (#6451) - codegens not true codegens not true - codegens not nilable type (false) codegens not nilable type (false) - codegens not nil codegens not nil - codegens not false codegens not false -Code gen: named tuple - codegens tuple index codegens tuple index - does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class does to_s for NamedTuple class - upcasts named tuple union to compatible named tuple upcasts named tuple union to compatible named tuple - codegens tuple nilable index (3) codegens tuple nilable index (3) - provides T as a named tuple literal provides T as a named tuple literal - assigns named tuple union to compatible named tuple assigns named tuple union to compatible named tuple - merges two named tuple types with same keys but different types (2) merges two named tuple types with same keys but different types (2) - downcasts union inside tuple to value (#3907) downcasts union inside tuple to value (#3907) - upcasts named tuple inside union to union with compatible named tuple upcasts named tuple inside union to union with compatible named tuple - assigns two same-size named tuple types to a same var (#3132) assigns two same-size named tuple types to a same var (#3132) - gets keys at compile time (1) gets keys at compile time (1) - codegens union of tuple of float with tuple of tuple of float codegens union of tuple of float with tuple of tuple of float - codegens tuple nilable index (1) codegens tuple nilable index (1) - assigns named tuple to compatible named tuple assigns named tuple to compatible named tuple - codegens tuple nilable index (2) codegens tuple nilable index (2) - doesn't error if NamedTuple includes a non-generic module (#10380) doesn't error if NamedTuple includes a non-generic module (#10380) - gets keys at compile time (2) gets keys at compile time (2) - allows named tuple covariance allows named tuple covariance - assigns named tuple inside union to union with compatible named tuple assigns named tuple inside union to union with compatible named tuple - accesses T and creates instance from it accesses T and creates instance from it - upcasts named tuple inside compatible named tuple upcasts named tuple inside compatible named tuple - codegens tuple index another order codegens tuple index another order - passes named tuple to def passes named tuple to def - gets size at compile time gets size at compile time - merges two named tuple types with same keys but different types (1) merges two named tuple types with same keys but different types (1) - doesn't crash when overload doesn't match doesn't crash when overload doesn't match -Semantic: struct - doesn't make virtual for Struct doesn't make virtual for Struct - allows struct to participate in virtual allows struct to participate in virtual - can't reopen as class can't reopen as class - unifies type to virtual type unifies type to virtual type - errors if defining finalize for struct (#3840) errors if defining finalize for struct (#3840) - doesn't make virtual for Float doesn't make virtual for Float - passes subtype check with generic module type on virtual type passes subtype check with generic module type on virtual type - passes subtype check with generic module type on virtual type (3) passes subtype check with generic module type on virtual type (3) - types struct declaration types struct declaration - can't reopen as module can't reopen as module - types generic struct declaration types generic struct declaration - can't extend struct from class can't extend struct from class - can't be nilable can't be nilable - doesn't make virtual for Value doesn't make virtual for Value - passes subtype check with generic module type on virtual type (2) (#10302) passes subtype check with generic module type on virtual type (2) (#10302) - doesn't error if method is not found in abstract type doesn't error if method is not found in abstract type - doesn't make virtual for Int doesn't make virtual for Int - can't extend struct from non-abstract struct can't extend struct from non-abstract struct - can't extend class from struct can't extend class from struct - can cast to base abstract struct can cast to base abstract struct -Crystal::Macro - macro id methods - forwards methods to string forwards methods to string - compares with string compares with string - compares with symbol compares with symbol - proc notation methods - gets multiple inputs gets multiple inputs - gets empty output gets empty output - gets single input gets single input - executes resolve executes resolve - gets single output gets single output - executes resolve? executes resolve? - type declaration methods - executes type executes type - executes var when instance var executes var when instance var - executes var executes var - executes value executes value - responds_to methods - executes receiver executes receiver - executes name executes name - Crystal::ArrayLiteral - executes any? (false) executes any? (false) - executes find (finds) executes find (finds) - #+ - with TupleLiteral argument - concatenates the literals into an ArrayLiteral concatenates the literals into an ArrayLiteral - with ArrayLiteral argument - concatenates the literals into an ArrayLiteral concatenates the literals into an ArrayLiteral - executes empty? executes empty? - #each #each - executes splat with symbols and strings executes splat with symbols and strings - executes sort with strings executes sort with strings - executes last executes last - executes sort with ids executes sort with ids - executes sort with ids and strings executes sort with ids and strings - executes all? (false) executes all? (false) - executes join executes join - executes push executes push - executes identify executes identify - executes any? (true) executes any? (true) - executes map with constants executes map with constants - executes []= executes []= - executes uniq executes uniq - #map_with_index - without either argument - returns the resulting array returns the resulting array - with both arguments - returns the resulting array returns the resulting array - without the index argument - returns the resulting array returns the resulting array - without the element argument - returns the resulting array returns the resulting array - executes [] with two numbers executes [] with two numbers - executes type executes type - executes sort_by executes sort_by - executes find (doesn't find) executes find (doesn't find) - executes join with strings executes join with strings - #each_with_index - with both arguments - builds the correct array builds the correct array - without the element argument - builds the correct array builds the correct array - without the index argument - builds the correct array builds the correct array - without either argument - builds the correct array builds the correct array - executes includes? executes includes? - executes map with arg executes map with arg - executes sort with numbers executes sort with numbers - executes [] with incomplete range executes [] with incomplete range - executes splat with splat executes splat with splat - executes of executes of - executes of (nop) executes of (nop) - executes splat executes splat - executes select executes select - executes reject executes reject - executes map executes map - calls block exactly once for each element in #sort_by calls block exactly once for each element in #sort_by - executes index 0 executes index 0 - executes reduce with no initial value executes reduce with no initial value - executes type (nop) executes type (nop) - executes [] with computed range executes [] with computed range - #- - with ArrayLiteral argument - removes the elements in RHS from LHS into an ArrayLiteral removes the elements in RHS from LHS into an ArrayLiteral - with TupleLiteral argument - removes the elements in RHS from LHS into an ArrayLiteral removes the elements in RHS from LHS into an ArrayLiteral - executes all? (true) executes all? (true) - executes [] with range executes [] with range - executes size executes size - executes index 1 executes index 1 - executes is_a? executes is_a? - executes reduce with initial value executes reduce with initial value - executes first executes first - executes index out of bounds executes index out of bounds - creates an array literal with a var creates an array literal with a var - executes unshift executes unshift - Crystal::TypeOf - executes args executes args - and methods - executes right executes right - executes left executes left - Crystal::External - executes is_a? executes is_a? - instancevar methods - executes name executes name - symbol methods - executes symbol != symbol executes symbol != symbol - forwards methods to string forwards methods to string - executes symbol == symbol executes symbol == symbol - Crystal::TupleLiteral - executes splat with symbols and strings executes splat with symbols and strings - executes includes? executes includes? - executes map with constants executes map with constants - executes sort with ids and strings executes sort with ids and strings - executes splat executes splat - executes splat with splat executes splat with splat - executes [] with range executes [] with range - executes sort with numbers executes sort with numbers - executes first executes first - executes size executes size - executes [] with computed range executes [] with computed range - #- - with ArrayLiteral argument - removes the elements in RHS from LHS into a TupleLiteral removes the elements in RHS from LHS into a TupleLiteral - with TupleLiteral argument - removes the elements in RHS from LHS into a TupleLiteral removes the elements in RHS from LHS into a TupleLiteral - executes push executes push - executes join with strings executes join with strings - executes select executes select - #each_with_index - without the element argument - builds the correct array builds the correct array - without the index argument - builds the correct array builds the correct array - with both arguments - builds the correct array builds the correct array - without either argument - builds the correct array builds the correct array - #each #each - executes any? (false) executes any? (false) - executes uniq executes uniq - creates a tuple literal with a var creates a tuple literal with a var - executes [] with incomplete range executes [] with incomplete range - executes last executes last - executes reject executes reject - executes is_a? executes is_a? - executes [] with 0 executes [] with 0 - executes [] out of bounds executes [] out of bounds - executes sort with ids executes sort with ids - executes all? (true) executes all? (true) - executes map executes map - executes empty? executes empty? - #map_with_index - without the element argument - returns the resulting tuple returns the resulting tuple - without the index argument - returns the resulting tuple returns the resulting tuple - without either argument - returns the resulting tuple returns the resulting tuple - with both arguments - returns the resulting tuple returns the resulting tuple - executes splat with arg executes splat with arg - executes map with arg executes map with arg - executes sort with strings executes sort with strings - executes any? (true) executes any? (true) - executes find (doesn't find) executes find (doesn't find) - executes unshift executes unshift - #+ - with TupleLiteral argument - concatenates the literals into a TupleLiteral concatenates the literals into a TupleLiteral - with ArrayLiteral argument - concatenates the literals into a TupleLiteral concatenates the literals into a TupleLiteral - executes all? (false) executes all? (false) - executes join executes join - executes find (finds) executes find (finds) - executes [] with 1 executes [] with 1 - compares versions compares versions - Crystal::MacroLiteral - executes value executes value - regex methods - executes source executes source - executes options executes options - classvar methods - executes name executes name - executes assign executes assign - Crystal::EnumDef - executes body executes body - executes base_type executes base_type - executes name executes name - executes kind executes kind - control expression methods - executes exp executes exp - executes exp (nop) executes exp (nop) - Crystal::TypeDef - executes name executes name - executes type executes type - node methods - #doc - returns the call's docs if present (wants_doc = true) returns the call's docs if present (wants_doc = true) - returns a multiline comment returns a multiline comment - returns an empty string if there are no docs on the node (wants_doc = false) returns an empty string if there are no docs on the node (wants_doc = false) - executes == on numbers (true) executes == on numbers (true) - executes == on symbols (true) (#240) executes == on symbols (true) (#240) - id - expands macro with id call on call expands macro with id call on call - expands macro with id call on char expands macro with id call on char - expands macro with id call on global path expands macro with id call on global path - expands macro with id call on string expands macro with id call on string - expands macro with id call on symbol expands macro with id call on symbol - expands macro with id call on number expands macro with id call on number - expands macro with id call on path expands macro with id call on path - executes == on numbers (false) executes == on numbers (false) - executes != on numbers (true) executes != on numbers (true) - location - line_number line_number - end line_number end line_number - end column number end column number - column number column number - filename filename - symbolize - expands macro with symbolize call on string expands macro with symbolize call on string - expands macro with symbolize call on symbol expands macro with symbolize call on symbol - expands macro with symbolize call on id expands macro with symbolize call on id - #nil? - Nop Nop - NilLiteral NilLiteral - NumberLiteral NumberLiteral - class_name - executes class_name executes class_name - executes class_name executes class_name - executes class_name executes class_name - executes class_name executes class_name - executes class_name executes class_name - executes class_name executes class_name - executes == on symbols (false) (#240) executes == on symbols (false) (#240) - stringify - expands macro with stringify call on number expands macro with stringify call on number - expands macro with stringify call on symbol expands macro with stringify call on symbol - expands macro with stringify call on call expands macro with stringify call on call - expands macro with stringify call on string expands macro with stringify call on string - #is_a? - union argument, contains NoReturn union argument, contains NoReturn - union argument, undefined types union argument, undefined types - union argument union argument - union argument, duplicate type union argument, duplicate type - union argument, mergeable union argument, mergeable - union argument, unimplemented types union argument, unimplemented types - executes != on numbers (false) executes != on numbers (false) - #doc_comment - returns an empty MacroId if there are no docs on the node (wants_doc = false) returns an empty MacroId if there are no docs on the node (wants_doc = false) - ensures each newline has a `#` prefix ensures each newline has a `#` prefix - returns the call's docs if present as a MacroId (wants_doc = true) returns the call's docs if present as a MacroId (wants_doc = true) - offsetof methods - executes offset executes offset - executes type executes type - executes assign without output executes assign without output - nilable cast methods - executes obj executes obj - executes to executes to - arg methods - executes default_value executes default_value - executes name executes name - executes internal_name executes internal_name - executes restriction executes restriction - unary expression methods - executes exp executes exp - executes is_a? executes is_a? - require methods - executes path executes path - yield methods - executes scope (nop) executes scope (nop) - executes expressions executes expressions - executes scope executes scope - Crystal::MacroExpression - executes output? executes output? - executes exp executes exp - macro if methods - executes cond executes cond - executes then executes then - executes else executes else - or methods - executes left executes left - executes right executes right - while methods - executes cond executes cond - executes body executes body - Crystal::Primitive - executes name executes name - readinstancevar methods - executes obj executes obj - executes name executes name - Crystal::CStructOrUnionDef - executes name executes name - executes body executes body - executes kind executes kind - executes union? executes union? - Crystal::MacroVar - executes name executes name - executes expressions executes expressions - Crystal::AsmOperand - executes constraint executes constraint - executes exp executes exp - macro methods - executes name executes name - executes double_splat executes double_splat - executes args executes args - executes splat_index executes splat_index - executes block_arg executes block_arg - executes visibility executes visibility - executes body executes body - macro for methods - executes exp executes exp - executes vars executes vars - executes body executes body - Crystal::FunDef - executes real_name executes real_name - executes has_body? executes has_body? - executes args executes args - executes name executes name - executes body executes body - executes variadic? executes variadic? - executes return_type executes return_type - union methods - executes resolve executes resolve - executes resolve? executes resolve? - executes types executes types - string methods - executes camelcase with invalid lower arg type executes camelcase with invalid lower arg type - executes string != string executes string != string - executes to_i executes to_i - executes gsub executes gsub - executes string > macroid executes string > macroid - executes [] with inclusive range executes [] with inclusive range - executes camelcase executes camelcase - executes string starts_with? string (true) executes string starts_with? string (true) - executes string == string executes string == string - executes split with argument executes split with argument - executes string starts_with? string (false) executes string starts_with? string (false) - executes string includes? string (true) executes string includes? string (true) - executes [] with incomplete range executes [] with incomplete range - executes chars executes chars - executes to_utf16 executes to_utf16 - executes size executes size - executes string > string executes string > string - executes string + char executes string + char - executes upcase executes upcase - executes strip executes strip - executes string includes? char (false) executes string includes? char (false) - executes underscore executes underscore - executes string < string executes string < string - executes camelcase with lower executes camelcase with lower - executes string + string executes string + string - executes string < macroid executes string < macroid - executes string includes? string (false) executes string includes? string (false) - executes string chomp executes string chomp - executes [] with computed range executes [] with computed range - executes string ends_with? string (true) executes string ends_with? string (true) - executes count executes count - executes downcase executes downcase - executes lines executes lines - executes string starts_with? char (true) executes string starts_with? char (true) - executes empty executes empty - executes string includes? char (true) executes string includes? char (true) - executes split with char argument executes split with char argument - executes string =~ (true) executes string =~ (true) - executes string =~ (false) executes string =~ (false) - executes string ends_with? string (false) executes string ends_with? string (false) - executes [] with exclusive range executes [] with exclusive range - executes split without arguments executes split without arguments - executes string ends_with? char (true) executes string ends_with? char (true) - executes capitalize executes capitalize - executes string starts_with? char (false) executes string starts_with? char (false) - executes titleize executes titleize - executes to_i(base) executes to_i(base) - executes tr executes tr - executes string ends_with? char (false) executes string ends_with? char (false) - visibility modifier methods - executes exp executes exp - executes visibility executes visibility - if methods - executes then executes then - executes cond executes cond - executes else executes else - executes else (nop) executes else (nop) - annotation methods - executes [] with other ASTNode, but raises an error executes [] with other ASTNode, but raises an error - executes [] with SymbolLiteral executes [] with SymbolLiteral - executes name executes name - executes [] with MacroId executes [] with MacroId - executes [] with NumberLiteral executes [] with NumberLiteral - executes [] with StringLiteral executes [] with StringLiteral - splat methods - executes exp executes exp - uninitialized var methods - executes var executes var - executes type executes type - Crystal::Asm - executes inputs executes inputs - executes alignstack? executes alignstack? - executes can_throw? executes can_throw? - executes clobbers executes clobbers - executes intel? executes intel? - executes text executes text - executes outputs executes outputs - executes volatile? executes volatile? - printing - print print - p! p! - pp! pp! - puts puts - pp pp - p p - proc pointer methods - executes args when empty executes args when empty - executes args when not empty executes args when not empty - executes obj when present executes obj when present - executes global? executes global? - executes obj when absent executes obj when absent - executes name executes name - Crystal::ExternalVar - executes type executes type - executes name executes name - executes real_name executes real_name - assign methods - executes target executes target - executes value executes value - #parse_type - raises on extra unparsed tokens after the type raises on extra unparsed tokens after the type - generic generic - exposes syntax warnings exposes syntax warnings - path path - raises on extra unparsed tokens before the type raises on extra unparsed tokens before the type - union - | union - | - union - in generic union - in generic - metaclass metaclass - raises on non StringLiteral arguments raises on non StringLiteral arguments - proc proc - union - Union union - Union - raises on empty string raises on empty string - generic methods - executes resolve executes resolve - executes type_vars executes type_vars - executes types executes types - executes name executes name - executes named_args executes named_args - executes resolve? executes resolve? - cast methods - executes to executes to - executes obj executes obj - Crystal::TypeNode - executes instance executes instance - executes class_vars on symbol type executes class_vars on symbol type - #union? - false false - true true - executes >= executes >= - executes instance_vars executes instance_vars - #nilable? - true true - false false - executes == executes == - #name - simple type - returns the name of the type returns the name of the type - generic instance - does not print extra commas for empty splat type var (2) does not print extra commas for empty splat type var (2) - prints generic type arguments prints generic type arguments - prints empty splat type var prints empty splat type var - does not print extra commas for empty splat type var (3) does not print extra commas for empty splat type var (3) - prints multiple arguments for splat type var prints multiple arguments for splat type var - does not print extra commas for empty splat type var (1) does not print extra commas for empty splat type var (1) - namespaced type - should return the FQN of the type should return the FQN of the type - generic type - includes the generic_args of the instantiated type by default includes the generic_args of the instantiated type by default - includes the generic_args of the type by default includes the generic_args of the type by default - generic_args - true - includes the generic_args of the instantiated type includes the generic_args of the instantiated type - includes the generic_args of the type includes the generic_args of the type - false - does not include the generic_args of the type does not include the generic_args of the type - does not include the generic_args of the instantiated type does not include the generic_args of the instantiated type - with an invalid type argument - should raise the proper exception should raise the proper exception - executes methods executes methods - public? - false false - true true - executes resolve executes resolve - executes class vars (with inheritance) executes class vars (with inheritance) - visibility - public public - private private - #warning - emits a warning at a specific node emits a warning at a specific node - executes ancestors executes ancestors - #abstract? - Crystal::GenericClassType - struct - non-abstract non-abstract - abstract abstract - class - non-abstract non-abstract - abstract abstract - Crystal::NonGenericClassType - class - abstract abstract - non-abstract non-abstract - struct - abstract abstract - non-abstract non-abstract - Crystal::GenericModuleType Crystal::GenericModuleType - Crystal::NonGenericModuleType Crystal::NonGenericModuleType - #id - does not include trailing + for virtual type does not include trailing + for virtual type - executes instance_vars on symbol type executes instance_vars on symbol type - executes union_types (union) executes union_types (union) - executes superclass executes superclass - executes size of tuple executes size of tuple - executes < executes < - executes class vars executes class vars - #has_inner_pointers? - works on structs works on structs - works on primitive values works on primitive values - works on ReferenceStorage works on ReferenceStorage - works on references works on references - #struct? - Crystal::GenericModuleType Crystal::GenericModuleType - Crystal::GenericClassType - class class - struct struct - Crystal::NonGenericModuleType Crystal::NonGenericModuleType - Crystal::NonGenericClassType - struct struct - class class - executes class_vars on metaclass executes class_vars on metaclass - executes <= executes <= - executes resolve? executes resolve? - executes class methods executes class methods - executes > executes > - executes private? - false false - true true - executes class executes class - executes != executes != - executes size of tuple metaclass executes size of tuple metaclass - #class? - Crystal::NonGenericClassType - class class - struct struct - Crystal::GenericClassType - struct struct - class class - Crystal::GenericModuleType Crystal::GenericModuleType - Crystal::NonGenericModuleType Crystal::NonGenericModuleType - executes instance_vars on metaclass executes instance_vars on metaclass - executes type_vars executes type_vars - #module? - Crystal::NonGenericModuleType Crystal::NonGenericModuleType - Crystal::GenericClassType - struct struct - class class - Crystal::GenericModuleType Crystal::GenericModuleType - Crystal::NonGenericClassType - struct struct - class class - executes union_types (non-union) executes union_types (non-union) - #includers - returns an array of types `self` is directly included in returns an array of types `self` is directly included in - == and != devirtualize generic type arguments (#10730) == and != devirtualize generic type arguments (#10730) - executes ancestors (with generic) executes ancestors (with generic) - Crystal::LibDef - executes name executes name - executes body executes body - executes kind executes kind - proc literal methods - executes body executes body - executes args executes args - executes return_type executes return_type - path methods - executes names executes names - executes global? executes global? - executes resolve executes resolve - executes types executes types - executes global executes global - executes resolve? executes resolve? - Crystal::RangeLiteral - executes map executes map - executes to_a executes to_a - #each #each - executes begin executes begin - executes end executes end - executes excludes_end? executes excludes_end? - Crystal::ModuleDef - executes body executes body - executes splat_index executes splat_index - executes name executes name - executes kind executes kind - executes type_vars executes type_vars - metaclass methods - executes resolve executes resolve - executes resolve? executes resolve? - executes instance executes instance - block methods - executes body executes body - executes splat_index executes splat_index - executes args executes args - exception handler methods - executes else executes else - executes rescues executes rescues - executes ensure executes ensure - executes ensure (nop) executes ensure (nop) - executes rescue body executes rescue body - executes rescue name executes rescue name - executes rescue types executes rescue types - executes else (nop) executes else (nop) - executes body executes body - Crystal::NamedTupleLiteral - executes map executes map - executes size executes size - executes values executes values - executes double splat executes double splat - executes empty? executes empty? - executes to_a executes to_a - executes [] not found executes [] not found - executes keys executes keys - executes double splat executes double splat - executes has_key? executes has_key? - creates a named tuple literal with a var creates a named tuple literal with a var - executes double splat with arg executes double splat with arg - executes []= executes []= - executes [] executes [] - #each - without the key argument - builds the correct array builds the correct array - without the value argument - builds the correct array builds the correct array - with both arguments - builds the correct array builds the correct array - without either argument - builds the correct array builds the correct array - executes [] with invalid key type executes [] with invalid key type - executes is_a? executes is_a? - flag? - has flag has flag - doesn't have flag doesn't have flag - expressions methods - executes expressions executes expressions - metavar methods - executes name executes name - executes id executes id - executes nothing executes nothing - executes is_a? executes is_a? - call methods - executes block executes block - executes block arg (nop) executes block arg (nop) - executes global? executes global? - executes receiver executes receiver - executes name executes name - executes block arg executes block arg - executes args executes args - executes named args name executes named args name - executes named args executes named args - executes named args value executes named args value - env - has key has key - doesn't have key doesn't have key - Crystal::Include - executes name executes name - char methods - executes ord executes ord - #warning - emits a top level warning emits a top level warning - global methods - executes name executes name - Crystal::ClassDef - executes body executes body - executes splat_index executes splat_index - executes struct? executes struct? - executes superclass executes superclass - executes type_vars executes type_vars - executes abstract? executes abstract? - executes kind executes kind - executes name executes name - Crystal::Extend - executes name executes name - number methods - executes > (false) executes > (false) - executes // executes // - executes ^ executes ^ - executes > (true) executes > (true) - executes unary - executes unary - - executes >> executes >> - executes <=> executes <=> - executes kind executes kind - executes < (true) executes < (true) - executes ** executes ** - executes << executes << - preserves integer size (#10713) preserves integer size (#10713) - executes + executes + - executes % executes % - executes < (false) executes < (false) - executes unary ~ executes unary ~ - executes - executes - - executes unary + executes unary + - executes >= (true) executes >= (true) - executes <= (true) executes <= (true) - executes math operations using U/Int128 executes math operations using U/Int128 - executes <= (false) executes <= (false) - executes <=> (returns nil) executes <=> (returns nil) - executes | executes | - executes + and preserves type executes + and preserves type - executes * executes * - #to_number #to_number - executes + with float executes + with float - executes >= (false) executes >= (false) - executes & executes & - multi_assign methods - executes values executes values - executes targets executes targets - Crystal::Alias - executes type executes type - executes name executes name - is_a methods - executes arg executes arg - executes receiver executes receiver - Crystal::Select - executes whens executes whens - executes else executes else - Crystal::AnnotationDef - executes kind executes kind - executes body executes body - executes name executes name - instancevar methods - executes name executes name - def methods - executes abstract? executes abstract? - executes receiver executes receiver - executes return_type executes return_type - executes accepts_block? executes accepts_block? - executes splat_index executes splat_index - executes visibility executes visibility - executes block_arg executes block_arg - executes body executes body - executes args executes args - executes name executes name - executes double_splat executes double_splat - executes free_vars executes free_vars - Crystal::HashLiteral - executes has_key? executes has_key? - executes to_a executes to_a - executes of_value (nop) executes of_value (nop) - executes type executes type - executes values executes values - executes keys executes keys - creates a hash literal with a var creates a hash literal with a var - executes [] not found executes [] not found - executes of_key (nop) executes of_key (nop) - executes type (nop) executes type (nop) - executes of_key executes of_key - executes double splat with arg executes double splat with arg - #each - without the key argument - builds the correct array builds the correct array - without either argument - builds the correct array builds the correct array - with both arguments - builds the correct array builds the correct array - without the value argument - builds the correct array builds the correct array - executes is_a? executes is_a? - executes [] executes [] - executes size executes size - executes map executes map - executes []= executes []= - executes of_value executes of_value - executes empty? executes empty? - executes double splat executes double splat - executes double splat executes double splat - case methods - when - executes when exhaustive? executes when exhaustive? - executes cond executes cond - executes exhaustive? executes exhaustive? - executes whens executes whens - executes when conds executes when conds - executes when body executes when body - executes else executes else - in - executes when exhaustive? executes when exhaustive? - executes exhaustive? executes exhaustive? - executes whens executes whens -Code gen: or - codegens or with bool false and true codegens or with bool false and true - codegens or with bool union as left node 3 codegens or with bool union as left node 3 - codegens or with nilable as left node 1 codegens or with nilable as left node 1 - codegens or with bool false and false codegens or with bool false and false - codegens or with non-false union as left node codegens or with non-false union as left node - codegens or with bool union as left node 1 codegens or with bool union as left node 1 - codegens or with bool union as left node 1 codegens or with bool union as left node 1 - codegens or with primitive type other than bool with union codegens or with primitive type other than bool with union - codegens or with bool union as left node 2 codegens or with bool union as left node 2 - codegens or with nilable as left node 2 codegens or with nilable as left node 2 - codegens or with primitive type other than bool codegens or with primitive type other than bool - codegens or with bool union as left node 4 codegens or with bool union as left node 4 - codegens or with bool true and true codegens or with bool true and true - codegens or with bool true and false codegens or with bool true and false - codegens or with bool union as left node 2 codegens or with bool union as left node 2 - codegens or with primitive type other than bool codegens or with primitive type other than bool - codegens or with bool and int 2 codegens or with bool and int 2 - codegens or with bool union as left node 3 codegens or with bool union as left node 3 - codegens or with nil union as left node 2 codegens or with nil union as left node 2 - codegens or with bool and int 1 codegens or with bool and int 1 - codegens or with nil union as left node 1 codegens or with nil union as left node 1 -Semantic: nilable instance var - says self was used before instance var was initialized (3) says self was used before instance var was initialized (3) - says self was used before instance var was initialized (2) says self was used before instance var was initialized (2) - says instance var was not initialized in all of the initialize methods (2) says instance var was not initialized in all of the initialize methods (2) - says instance var was not initialized in all of the initialize methods, with var declaration says instance var was not initialized in all of the initialize methods, with var declaration - marks instance var as nilable if assigned inside proc literal marks instance var as nilable if assigned inside proc literal - doesn't consider as nil if initialized with catch-all doesn't consider as nil if initialized with catch-all - says instance var was used before initialized says instance var was used before initialized - says instance var was used before initialized (2) says instance var was used before initialized (2) - finds type that doesn't initialize instance var (#1222) finds type that doesn't initialize instance var (#1222) - marks instance var as nilable if assigned inside captured block (#1696) marks instance var as nilable if assigned inside captured block (#1696) - says instance var was not initialized in all of the initialize methods says instance var was not initialized in all of the initialize methods - says self was used before instance var was initialized says self was used before instance var was initialized -Code gen: and - codegens assign in right node, after if must be nilable codegens assign in right node, after if must be nilable - codegens and with primitive type other than bool with union codegens and with primitive type other than bool with union - codegens and with bool union as left node 1 codegens and with bool union as left node 1 - codegens assign in right node, inside if must not be nil codegens assign in right node, inside if must not be nil - codegens and with bool union as left node 3 codegens and with bool union as left node 3 - codegens and with bool true and true codegens and with bool true and true - codegens and with bool false and false codegens and with bool false and false - codegens and with nil union as left node 1 codegens and with nil union as left node 1 - codegens and with bool union as left node 3 codegens and with bool union as left node 3 - codegens and with primitive type other than bool codegens and with primitive type other than bool - codegens assign in right node, after must be nilable codegens assign in right node, after must be nilable - codegens and with bool union as left node 2 codegens and with bool union as left node 2 - codegens and with bool and int 2 codegens and with bool and int 2 - codegens and with bool false and true codegens and with bool false and true - codegens and with bool union as left node 2 codegens and with bool union as left node 2 - codegens and with nil union as left node 2 codegens and with nil union as left node 2 - codegens and with bool union as left node 1 codegens and with bool union as left node 1 - codegens and with nilable as left node 2 codegens and with nilable as left node 2 - codegens and with bool true and false codegens and with bool true and false - codegens and with bool and int 1 codegens and with bool and int 1 - codegens and with non-false union as left node codegens and with non-false union as left node - codegens and with nilable as left node 1 codegens and with nilable as left node 1 - codegens and with primitive type other than bool codegens and with primitive type other than bool - codegens and with bool union as left node 4 codegens and with bool union as left node 4 -Crystal::Doc::MarkdDocRenderer - renders code spans - renders "`