kcl-lib 0.2.151

KittyCAD Language implementation and tools
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use uuid::Uuid;

use crate::SourceRange;
use crate::errors::KclError;
use crate::errors::KclErrorDetails;
use crate::execution::ConsumedSolidInfo;
use crate::execution::ConsumedSolidOperation;
use crate::execution::ExecState;
use crate::execution::KclValue;
use crate::execution::Solid;

pub(crate) fn validate_value_not_consumed(
    value: &KclValue,
    exec_state: &ExecState,
    source_range: SourceRange,
) -> Result<(), KclError> {
    match value {
        KclValue::Solid { value } => validate_solid_not_consumed(value, exec_state, source_range),
        KclValue::HomArray { value, .. } | KclValue::Tuple { value, .. } => value
            .iter()
            .try_for_each(|v| validate_value_not_consumed(v, exec_state, source_range)),
        KclValue::Object { value, .. } => value
            .values()
            .try_for_each(|v| validate_value_not_consumed(v, exec_state, source_range)),
        _ => Ok(()),
    }
}

pub(super) fn validate_solids_not_consumed(
    solids: &[Solid],
    exec_state: &ExecState,
    source_range: SourceRange,
) -> Result<(), KclError> {
    solids
        .iter()
        .try_for_each(|solid| validate_solid_not_consumed(solid, exec_state, source_range))
}

fn validate_solid_not_consumed(
    solid: &Solid,
    exec_state: &ExecState,
    source_range: SourceRange,
) -> Result<(), KclError> {
    let Some(info) = exec_state.check_solid_consumed(&solid.id) else {
        return Ok(());
    };
    let operation = info.operation;
    let output_solid_id = info.output_solid_id;
    let consumed_var = exec_state.find_var_name_for_solid_id(solid.id);
    let output_var = exec_state
        .latest_consumed_output(output_solid_id)
        .and_then(|id| exec_state.find_var_name_for_solid_id(id));
    let message = build_consumed_error_message(consumed_var.as_deref(), operation, output_var.as_deref());

    Err(KclError::new_semantic(KclErrorDetails::new(
        message,
        vec![source_range],
    )))
}

pub(super) fn record_consumed_solids(
    exec_state: &mut ExecState,
    solids: &[Solid],
    operation: ConsumedSolidOperation,
    output_solid_id: Option<Uuid>,
) {
    for solid in solids {
        exec_state.mark_solid_consumed(
            solid.id,
            ConsumedSolidInfo {
                operation,
                output_solid_id,
            },
        );
    }
}

fn build_consumed_error_message(
    consumed_var: Option<&str>,
    operation: ConsumedSolidOperation,
    output_var: Option<&str>,
) -> String {
    let article = operation.indefinite_article();

    match (consumed_var, output_var) {
        (Some(consumed), Some(output)) => format!(
            "`{consumed}` was already consumed by {article} `{operation}` operation. \
             The operation result is now in `{output}`; use that for subsequent operations."
        ),
        (Some(consumed), None) => format!(
            "`{consumed}` was already consumed by {article} `{operation}` operation \
             and can no longer be used. Some operations destroy their inputs; \
             assign the result to a variable and use it for subsequent operations."
        ),
        (None, Some(output)) => format!(
            "A solid was already consumed by {article} `{operation}` operation. \
             The operation result is now in `{output}`; use that for subsequent operations."
        ),
        (None, None) => format!(
            "A solid was already consumed by {article} `{operation}` operation \
             and can no longer be used. Some operations destroy their inputs; \
             assign the result to a variable and use it for subsequent operations."
        ),
    }
}