ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d461b09a4dee004c75043c79766dff24c38a2209
modeling-app/src/wasm-lib/kcl/tests/sketch_in_object/ast.snap

847 lines
32 KiB
Plaintext
Raw Normal View History

Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
---
source: kcl/src/simulation_tests.rs
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
assertion_line: 52
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
description: Result of parsing sketch_in_object.kcl
snapshot_kind: text
---
{
"Ok": {
"body": [
{
"declarations": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 167,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"id": {
"end": 7,
"name": "test",
"start": 3,
"type": "Identifier"
},
"init": {
"body": {
"body": [
{
"argument": {
"body": [
{
"arguments": [
{
"end": 45,
"raw": "'XY'",
"start": 41,
"type": "Literal",
"type": "Literal",
"value": "XY"
}
],
"callee": {
"end": 40,
"name": "startSketchOn",
"start": 27,
"type": "Identifier"
},
"end": 46,
"optional": false,
"start": 27,
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 71,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 70,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 74,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 73,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 75,
"start": 69,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 78,
"start": 77,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 68,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "startProfileAt",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 54,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 79,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 54,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 94,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 93,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 97,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "1",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 96,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 1.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 98,
"start": 92,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 101,
"start": 100,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 91,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "line",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 87,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 102,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 87,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 117,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "1",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 116,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 1.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 120,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 119,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 121,
"start": 115,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 124,
"start": 123,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 114,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "line",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 110,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 125,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 110,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 140,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 139,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
"argument": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 144,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "1",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 143,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 1.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 144,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"operator": "-",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 142,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "UnaryExpression",
"type": "UnaryExpression"
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 145,
"start": 138,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 148,
"start": 147,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 137,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "line",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 133,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 149,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 133,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 164,
"start": 163,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 162,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "close",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 157,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 165,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 157,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 165,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"start": 27,
"type": "PipeExpression",
"type": "PipeExpression"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 165,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"start": 20,
"type": "ReturnStatement",
"type": "ReturnStatement"
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 167,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"start": 16
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 167,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"params": [],
"start": 10,
"type": "FunctionExpression",
"type": "FunctionExpression"
},
"start": 3,
"type": "VariableDeclarator"
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 167,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"kind": "fn",
"start": 0,
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
"declarations": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 399,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"id": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 177,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "test2",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 172,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
"init": {
"body": {
"body": [
{
"argument": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 397,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"properties": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 393,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"key": {
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 209,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "thing1",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 203,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 203,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ObjectProperty",
"value": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 393,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"properties": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 387,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"key": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 226,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "thing2",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 220,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 220,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ObjectProperty",
"value": {
"body": [
{
"arguments": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 247,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "'XY'",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 243,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
"value": "XY"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 242,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "startSketchOn",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 229,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 248,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 229,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 277,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 276,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 280,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 279,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 281,
"start": 275,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 284,
"start": 283,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 274,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "startProfileAt",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 260,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 285,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 260,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 304,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 303,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 307,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "1",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 306,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 1.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 308,
"start": 302,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 311,
"start": 310,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 301,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "line",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 297,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 312,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 297,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 331,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "1",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 330,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 1.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 334,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 333,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 335,
"start": 329,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 338,
"start": 337,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 328,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "line",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 324,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 339,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 324,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"elements": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 358,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "0",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 357,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 0.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
"argument": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 362,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "1",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 361,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 1.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 362,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"operator": "-",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 360,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "UnaryExpression",
"type": "UnaryExpression"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 363,
"start": 356,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ArrayExpression",
"type": "ArrayExpression"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 366,
"start": 365,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 355,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "line",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 351,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 367,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 351,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 386,
"start": 385,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 384,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "close",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 379,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 387,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 379,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 387,
"start": 229,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeExpression",
"type": "PipeExpression"
}
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 212,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ObjectExpression",
"type": "ObjectExpression"
}
}
],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 197,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ObjectExpression",
"type": "ObjectExpression"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 397,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 190,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ReturnStatement",
"type": "ReturnStatement"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 399,
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 186
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 399,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"params": [],
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 180,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "FunctionExpression",
"type": "FunctionExpression"
},
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 172,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "VariableDeclarator"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 399,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"kind": "fn",
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"start": 169,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
"declarations": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 411,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"id": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 402,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "x",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 401,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
"init": {
"arguments": [],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 409,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "test",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 405,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 411,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 405,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 401,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "VariableDeclarator"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 411,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"kind": "const",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 401,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 434,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"expression": {
"body": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 413,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "x",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 412,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier",
"type": "Identifier"
},
{
"arguments": [
{
"argument": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 430,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "10",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 428,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 10.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 430,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"operator": "-",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 427,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "UnaryExpression",
"type": "UnaryExpression"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 433,
"start": 432,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 426,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "extrude",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 419,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 434,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 419,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 434,
"start": 412,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeExpression",
"type": "PipeExpression"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 412,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ExpressionStatement",
"type": "ExpressionStatement"
},
{
"declarations": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 448,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"id": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 438,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "x2",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 436,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
"init": {
"arguments": [],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 446,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "test2",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 441,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 448,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 441,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 436,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "VariableDeclarator"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 448,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"kind": "const",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 436,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 485,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"expression": {
"body": [
{
"computed": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 465,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"object": {
"computed": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 458,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"object": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 451,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "x2",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 449,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier",
"type": "Identifier"
},
"property": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 458,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "thing1",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 452,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier",
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 449,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "MemberExpression",
"type": "MemberExpression"
},
"property": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 465,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "thing2",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 459,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier",
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 449,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "MemberExpression",
"type": "MemberExpression"
},
{
"arguments": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 481,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"raw": "10",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 479,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Literal",
"type": "Literal",
Implicit conversion of round numbers to integers (#4542) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 10:50:43 +13:00
"value": 10.0
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
},
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 484,
"start": 483,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeSubstitution",
"type": "PipeSubstitution"
}
],
"callee": {
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 478,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"name": "extrude",
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 471,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "Identifier"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 485,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"optional": false,
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 471,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "CallExpression",
"type": "CallExpression"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 485,
"start": 449,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "PipeExpression",
"type": "PipeExpression"
},
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"start": 449,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "ExpressionStatement",
"type": "ExpressionStatement"
}
],
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 486,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"nonCodeMeta": {
"nonCodeNodes": {
"0": [
{
Fix formatting for nested function returns (#4518) Previously, this was the output of the formatter: ``` fn f = () => { return () => { return 1 } } ``` Now the above will be reformatted as ``` fn f = () => { return () => { return 1 } } ``` Much better!
2024-11-20 08:23:30 -06:00
"end": 169,
"start": 167,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "NonCodeNode",
"value": {
"type": "newLine"
}
}
],
"1": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 401,
"start": 399,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "NonCodeNode",
"value": {
"type": "newLine"
}
}
],
"3": [
{
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-25 09:21:55 +13:00
"end": 436,
"start": 434,
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts.
2024-11-04 20:34:22 -06:00
"type": "NonCodeNode",
"value": {
"type": "newLine"
}
}
]
},
"startNodes": []
},
"start": 0
}
}
Reference in New Issue Copy Permalink