ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4b6166dc4f66730809c65a5ecdd810a110de9054
modeling-app/rust/kcl-lib/tests/kw_fn/ast.snap

295 lines
7.5 KiB
Plaintext
Raw Normal View History

AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
---
Various hover improvements (#5617) * Show more info on hover for variables Signed-off-by: Nick Cameron <nrc@ncameron.org> * Move hover impls to lsp module Signed-off-by: Nick Cameron <nrc@ncameron.org> * Make hover work on names inside calls, fix doc line breaking, trim docs in tool tips Signed-off-by: Nick Cameron <nrc@ncameron.org> * Test the new hovers; fix signature syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Hover tips for kwargs Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2025-03-04 22:53:31 +13:00
source: kcl-lib/src/simulation_tests.rs
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
description: Result of parsing kw_fn.kcl
---
{
"Ok": {
"body": [
{
"declaration": {
"end": 35,
"id": {
"end": 12,
"name": "increment",
"start": 3,
"type": "Identifier"
},
"init": {
"body": {
"body": [
{
"argument": {
"end": 33,
"left": {
"end": 29,
"name": "x",
"start": 28,
"type": "Identifier",
"type": "Identifier"
},
"operator": "+",
"right": {
"end": 33,
"raw": "1",
"start": 32,
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 1.0,
"suffix": "None"
}
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
},
"start": 28,
"type": "BinaryExpression",
"type": "BinaryExpression"
},
"end": 33,
"start": 21,
"type": "ReturnStatement",
"type": "ReturnStatement"
}
],
"end": 35,
"start": 17
},
"end": 35,
"params": [
{
"type": "Parameter",
"identifier": {
"end": 15,
"name": "x",
"start": 14,
"type": "Identifier"
},
"labeled": false
}
],
"start": 12,
"type": "FunctionExpression",
"type": "FunctionExpression"
},
"start": 3,
"type": "VariableDeclarator"
},
"end": 35,
"kind": "fn",
"start": 0,
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
"declaration": {
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"end": 77,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"id": {
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"end": 43,
"name": "add",
"start": 40,
"type": "Identifier"
},
"init": {
"body": {
"body": [
{
"argument": {
"end": 75,
"left": {
"end": 67,
"name": "x",
"start": 66,
"type": "Identifier",
"type": "Identifier"
},
"operator": "+",
"right": {
"end": 75,
"name": "delta",
"start": 70,
"type": "Identifier",
"type": "Identifier"
},
"start": 66,
"type": "BinaryExpression",
"type": "BinaryExpression"
},
"end": 75,
"start": 59,
"type": "ReturnStatement",
"type": "ReturnStatement"
}
],
"end": 77,
"start": 55
},
"end": 77,
"params": [
{
"type": "Parameter",
"identifier": {
"end": 46,
"name": "x",
"start": 45,
"type": "Identifier"
},
"labeled": false
},
{
"type": "Parameter",
"identifier": {
"end": 53,
"name": "delta",
"start": 48,
"type": "Identifier"
}
}
],
"start": 43,
"type": "FunctionExpression",
"type": "FunctionExpression"
},
"start": 40,
"type": "VariableDeclarator"
},
"end": 77,
"kind": "fn",
"start": 37,
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
"declaration": {
"end": 97,
"id": {
"end": 82,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"name": "two",
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"start": 79,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"type": "Identifier"
},
"init": {
"arguments": [
{
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"end": 96,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"raw": "1",
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"start": 95,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 1.0,
"suffix": "None"
}
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
}
],
"callee": {
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"end": 94,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"name": "increment",
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"start": 85,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"type": "Identifier"
},
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"end": 97,
"start": 85,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"type": "CallExpression",
"type": "CallExpression"
},
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"start": 79,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"type": "VariableDeclarator"
},
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"end": 97,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"kind": "const",
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"start": 79,
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
"declaration": {
KCL: Keyword fn args like "x = 1" not like "x: 1" (#4770) Aligns with how we're doing objects.
2024-12-12 11:53:35 -06:00
"end": 123,
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"id": {
"end": 103,
"name": "three",
"start": 98,
"type": "Identifier"
},
"init": {
"arguments": [
{
"type": "LabeledArg",
"label": {
Various hover improvements (#5617) * Show more info on hover for variables Signed-off-by: Nick Cameron <nrc@ncameron.org> * Move hover impls to lsp module Signed-off-by: Nick Cameron <nrc@ncameron.org> * Make hover work on names inside calls, fix doc line breaking, trim docs in tool tips Signed-off-by: Nick Cameron <nrc@ncameron.org> * Test the new hovers; fix signature syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Hover tips for kwargs Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2025-03-04 22:53:31 +13:00
"end": 118,
"name": "delta",
"start": 113,
"type": "Identifier"
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
},
"arg": {
KCL: Keyword fn args like "x = 1" not like "x: 1" (#4770) Aligns with how we're doing objects.
2024-12-12 11:53:35 -06:00
"end": 122,
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"raw": "2",
KCL: Keyword fn args like "x = 1" not like "x: 1" (#4770) Aligns with how we're doing objects.
2024-12-12 11:53:35 -06:00
"start": 121,
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 2.0,
"suffix": "None"
}
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
}
}
],
"callee": {
"end": 109,
"name": "add",
"start": 106,
"type": "Identifier"
},
KCL: Keyword fn args like "x = 1" not like "x: 1" (#4770) Aligns with how we're doing objects.
2024-12-12 11:53:35 -06:00
"end": 123,
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"start": 106,
"type": "CallExpressionKw",
"type": "CallExpressionKw",
"unlabeled": {
"end": 111,
"raw": "1",
"start": 110,
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 1.0,
"suffix": "None"
}
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
}
},
"start": 98,
"type": "VariableDeclarator"
},
KCL: Keyword fn args like "x = 1" not like "x: 1" (#4770) Aligns with how we're doing objects.
2024-12-12 11:53:35 -06:00
"end": 123,
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
"kind": "const",
"start": 98,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"type": "VariableDeclaration",
"type": "VariableDeclaration"
}
],
KCL: Keyword fn args like "x = 1" not like "x: 1" (#4770) Aligns with how we're doing objects.
2024-12-12 11:53:35 -06:00
"end": 124,
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
"nonCodeMeta": {
"nonCodeNodes": {
"0": [
{
"end": 37,
"start": 35,
"type": "NonCodeNode",
"value": {
"type": "newLine"
}
}
KCL keyword args: calling user-defined functions (#4722) Part of https://github.com/KittyCAD/modeling-app/issues/4600 You can now call a user-defined function via keyword args. E.g. ``` fn increment(@x) { return x + 1 } fn add(@x, delta) { return x + delta } two = increment(1) three = add(1, delta: 2) ```
2024-12-09 22:11:16 -06:00
],
"1": [
{
"end": 79,
"start": 77,
"type": "NonCodeNode",
"value": {
"type": "newLine"
}
}
AST: Allow unlabeled kw args (#4686) When declaring a function, its first parameter is allowed to be prefixed with `@`. This means that when users call this function, they don't have to label this argument. Only the first parameter is allowed this prefix, no others. Part of https://github.com/KittyCAD/modeling-app/issues/4600
2024-12-06 15:44:39 -06:00
]
},
"startNodes": []
},
"start": 0
}
}
Reference in New Issue Copy Permalink