devscout-rs 0.10.0

Fast code index for C# and TypeScript codebases -- map, find, refs, impact from the CLI.
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

use super::*;

#[test]
fn reserved_param_keys_ac_4_the_predicate_knows_exactly_the_reserved_spellings() {
    for key in [
        "@result:Index",
        "@result:",
        "@property:Depth",
        "@field:label",
        "@variant",
        "@implicit-conversion",
        "@interpolated-string-handler",
    ] {
        assert!(is_reserved_method_params_key(key), "{key} is reserved");
    }
    for key in [
        "Handle",
        "Index",
        "Invoke",
        "@event",
        "@class",
        "@result",
        "@property",
        "@field",
        "@variants",
        "@implicit-conversions",
        "@interpolated-string-handlers",
        "result:Index",
        "",
    ] {
        assert!(!is_reserved_method_params_key(key), "{key} is not reserved");
    }
}

#[test]
fn reserved_param_keys_ac_4_every_key_the_extractor_writes_is_classified_by_its_writer() {
    let e = extract_src(
        r#"
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace App.Reserved;

public interface ISource<out T>
{
    T Next();
}

public class Gauge
{
    private string label;

    public int Depth { get; set; }

    public Dictionary<int, TKey> Index<TKey>() => null;

    public void Handle(Gauge other) { }

    public void @event(Gauge other) { }

    public static implicit operator Gauge(int depth) => new Gauge();
}

[InterpolatedStringHandler]
public struct GaugeHandler
{
    public void AppendLiteral(string text) { }
}

public delegate void Reading(Gauge gauge);
"#,
    );
    let mut reserved = Vec::new();
    let mut ordinary = Vec::new();
    for d in &e.defs {
        for (key, _) in d.method_params.iter() {
            if is_reserved_method_params_key(key) {
                reserved.push(key.clone());
            } else {
                ordinary.push(key.clone());
            }
        }
    }
    reserved.sort();
    ordinary.sort();
    assert_eq!(
        reserved,
        vec![
            "@field:label",
            "@implicit-conversion",
            "@interpolated-string-handler",
            "@property:Depth",
            "@result:Index",
            "@result:Next",
            "@variant",
        ]
    );
    assert_eq!(
        ordinary,
        vec![
            "@event",
            "AppendLiteral",
            "Handle",
            "Index",
            "Invoke",
            "Next"
        ]
    );
}