ink-analyzer 0.11.2

A library for semantic analysis of ink! smart contracts.
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
106
107
108
109
110
111
112
113
114
115

//! integration tests for ink! analyzer diagnostics.

mod utils;

use crate::utils::ink_version_from_path;
use ink_analyzer::{Analysis, TextRange, TextSize};
use test_utils::{PartialMatchStr, TestCaseResults};

// The high-level methodology for diagnostics test cases is:
// - Read the source code of an ink! entity file in the `test-fixtures` directory
//   (e.g. https://github.com/ink-analyzer/ink-analyzer/blob/master/test-fixtures/v4/erc20.rs).
// - (Optionally) Make modifications to the source code at specific offsets/text ranges to create a specific test case.
// - Compute diagnostics for the modified source code.
// - Verify that the actual results match the expected results.
// See inline comments for more details.
#[test]
fn diagnostics_works() {
    // Iterates over all test case groups (see [`test_utils::fixtures::diagnostics_fixtures`] doc and inline comments).
    for test_group in test_utils::fixtures::diagnostics_fixtures() {
        // Gets the original source code.
        let original_code = test_utils::read_source_code(test_group.source);

        // Iterates over all test cases.
        for test_case in test_group.test_cases {
            // Creates a copy of test code for this test case.
            let mut test_code = original_code.clone();

            // Applies test case modifications (if any).
            if let Some(modifications) = test_case.modifications {
                test_utils::apply_test_modifications(&mut test_code, &modifications);
            }

            // Runs diagnostics.
            let version = ink_version_from_path(test_group.source);
            let results = Analysis::new(&test_code, version).diagnostics();

            // Verifies diagnostics results.
            let expected_results = match test_case.results {
                TestCaseResults::Diagnostic { n, quickfixes } => Some((n, quickfixes)),
                _ => None,
            }
            .unwrap();
            assert_eq!(
                results.len(),
                expected_results.0,
                "source: {}",
                test_group.source
            );
            // Verifies quickfixes.
            for (idx, result) in results.iter().enumerate() {
                assert_eq!(
                    result.quickfixes.as_ref().map(Vec::len),
                    expected_results
                        .1
                        .get(idx)
                        .map(|(expected_quickfixes, _)| expected_quickfixes.len()),
                    "source: {}",
                    test_group.source
                );
                let expected_quickfixes = &expected_results.1[idx].0;
                if let Some(quickfixes) = result.quickfixes.as_ref() {
                    assert_eq!(
                        quickfixes
                            .iter()
                            .map(|action| (
                                PartialMatchStr::from(action.label.as_str()),
                                action
                                    .edits
                                    .iter()
                                    .map(|edit| (
                                        PartialMatchStr::from(edit.text.as_str()),
                                        edit.range
                                    ))
                                    .collect()
                            ))
                            .collect::<Vec<(PartialMatchStr, Vec<(PartialMatchStr, TextRange)>)>>(),
                        expected_quickfixes
                            .iter()
                            .map(|expected_action| (
                                PartialMatchStr::from(expected_action.label),
                                expected_action
                                    .edits
                                    .iter()
                                    .map(|result| (
                                        PartialMatchStr::from(result.text),
                                        TextRange::new(
                                            TextSize::from(
                                                test_utils::parse_offset_at(
                                                    &test_code,
                                                    result.start_pat
                                                )
                                                .unwrap()
                                                    as u32
                                            ),
                                            TextSize::from(
                                                test_utils::parse_offset_at(
                                                    &test_code,
                                                    result.end_pat
                                                )
                                                .unwrap()
                                                    as u32
                                            ),
                                        )
                                    ))
                                    .collect()
                            ))
                            .collect::<Vec<(PartialMatchStr, Vec<(PartialMatchStr, TextRange)>)>>(),
                        "source: {}",
                        test_group.source
                    );
                }
            }
        }
    }
}