Struct ara_reporting::Report

source · 
pub struct Report {
    pub issues: Vec<Issue>,
    pub footer: Option<ReportFooter>,
}

Fields§

§issues: Vec<Issue>§footer: Option<ReportFooter>

Implementations§

source§

impl Report

A report.

A report is a collection of issues.

Example:

use ara_reporting::Report;
use ara_reporting::ReportFooter;
use ara_reporting::issue::Issue;
use ara_reporting::issue::IssueSeverity;

let report = Report::new()
    .with_issue(Issue::error("0003", "standalone type `void` cannot be part of a union").with_source("main.ara", 10, 14))
    .with_issue(Issue::warning("0023", "...").with_source("some_file.ara", 9, 10))
    .with_footer(ReportFooter::new("This is a report message"));
source

pub fn new() -> Self

Create a new report.

Examples found in repository?
examples/cross_file.rs (line 40)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![
        Source::new(
            SourceKind::Script,
            "src/main.ara",
            r#"
use function Math\add;

function main(): int {
    $value = add(1, '2');

    $value
}
"#,
        ),
        Source::new(
            SourceKind::Script,
            "vendor/some-vendor/some-lib/src/add.ara",
            r#"
namespace Math;

function add(int $a, int $b): int {
    return $a + $b;
}
"#,
        ),
    ]);

    let report = Report::new().with_issue(
        Issue::error("", "mismatched types expected `{int}`, found `{string}`")
            .with_source("src/main.ara", 68, 71)
            .with_annotation(
                Annotation::secondary("src/main.ara", 61, 64)
                    .with_message("arguments to this function are incorrect"),
            )
            .with_annotation(
                Annotation::secondary("vendor/some-vendor/some-lib/src/add.ara", 27, 51)
                    .with_message("function defined here"),
            )
            .with_note(
                "you can cast a `{string}` to an `{int}` using `Psl\\Str\\to_int(...)` function",
            ),
    );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
More examples
Hide additional examples
examples/compact.rs (line 41)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![
        Source::new(
            SourceKind::Script,
            "src/main.ara",
            r#"
use function Math\add;

function main(): int {
    $value = add(1, '2');

    $value
}
"#,
        ),
        Source::new(
            SourceKind::Script,
            "vendor/some-vendor/some-lib/src/add.ara",
            r#"
namespace Math;

function add(int $a, int $b): int {
    return $a + $b;
}
"#,
        ),
    ]);

    let report = Report::new().with_issue(
        Issue::error("", "mismatched types expected `{int}`, found `{string}`")
            .with_source("src/main.ara", 68, 71)
            .with_annotation(
                Annotation::secondary("src/main.ara", 61, 64)
                    .with_message("arguments to this function are incorrect"),
            )
            .with_annotation(
                Annotation::secondary("vendor/some-vendor/some-lib/src/add.ara", 27, 51)
                    .with_message("function defined here"),
            )
            .with_note(
                "you can cast a `{string}` to an `{int}` using `Psl\\Str\\to_int(...)` function",
            ),
    );

    let builder = ReportBuilder::new(&map)
        .with_charset(CharSet::Unicode)
        .with_colors(ColorChoice::Always)
        .with_style(DisplayStyle::Compact);

    builder.print(&report)
}
examples/comfortable.rs (line 41)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![
        Source::new(
            SourceKind::Script,
            "src/main.ara",
            r#"
use function Math\add;

function main(): int {
    $value = add(1, '2');

    $value
}
"#,
        ),
        Source::new(
            SourceKind::Script,
            "vendor/some-vendor/some-lib/src/add.ara",
            r#"
namespace Math;

function add(int $a, int $b): int {
    return $a + $b;
}
"#,
        ),
    ]);

    let report = Report::new().with_issue(
        Issue::error("", "mismatched types expected `{int}`, found `{string}`")
            .with_source("src/main.ara", 68, 71)
            .with_annotation(
                Annotation::secondary("src/main.ara", 61, 64)
                    .with_message("arguments to this function are incorrect"),
            )
            .with_annotation(
                Annotation::secondary("vendor/some-vendor/some-lib/src/add.ara", 27, 51)
                    .with_message("function defined here"),
            )
            .with_note(
                "you can cast a `{string}` to an `{int}` using `Psl\\Str\\to_int(...)` function",
            ),
    );

    let builder = ReportBuilder::new(&map)
        .with_charset(CharSet::Unicode)
        .with_colors(ColorChoice::Always)
        .with_style(DisplayStyle::Comfortable);

    builder.print(&report)
}
examples/simple.rs (line 25)
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

fn main() -> Result<(), Error> {
    let origin = "example.ara";
    let code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let map = SourceMap::new(vec![Source::new(SourceKind::Script, origin, code)]);

    let report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
examples/collection.rs (line 34)
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

fn main() -> Result<(), Error> {
    let first_origin = "example.ara";
    let first_code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let second_origin = "example-2.ara";
    let second_code = r#"
function foo(Bar&float) {}
"#;

    let map = SourceMap::new(vec![
        Source::new(SourceKind::Script, first_origin, first_code),
        Source::new(SourceKind::Script, second_origin, second_code),
    ]);

    let first_report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(first_origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(first_origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let second_report = Report::new()
        .with_issue(
            Issue::error(
                "P0015",
                "scalar type `float` cannot be used in an intersection",
            )
            .with_source(second_origin, 18, 23)
            .with_annotation(
                Annotation::secondary(second_origin, 17, 19)
                    .with_message("scalar type `float` cannot be used in an intersection"),
            )
            .with_note("a scalar type is either `int`, `float`, `string`, or `bool`.")
            .with_note("try using a different type for the intersection."),
        )
        .with_issue(Issue::bug("B0001", "failed to read the file"))
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let reports: ReportCollection = vec![&first_report, &second_report];

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&reports)
}
examples/example.rs (line 35)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![Source::inline(
        SourceKind::Script,
        r#"
function main(): int|string {
    $a = 1;
    $b = 2;

    $c = $a + $b;

    $b = match ($a) {
        1 => 2,
        2 => 3,
        default => "string",
    };

    return $c + $b;
}
"#,
    )]);

    let report = Report::new()
        .with_issue(
            Issue::error("E123", "some error here")
                .with_source(DEFAULT_NAME, 35, 41)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 41, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W123", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W124", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::note("N123", "some note here")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 105, 112).with_message("an annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 121, 128)
                        .with_message("another annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 137, 147).with_message("and another"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::help("H123", "some help here")
                .with_source(DEFAULT_NAME, 137, 147)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 35, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::bug("E123", "`match` arms have incompatible types")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 110, 111)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 148, 156)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0308`"),
        )
        .with_footer(ReportFooter::new("this is a report footer message"));

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
source

pub fn with_issue(self, issue: Issue) -> Self

Add an issue to this report.

Examples found in repository?
examples/cross_file.rs (lines 40-54)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![
        Source::new(
            SourceKind::Script,
            "src/main.ara",
            r#"
use function Math\add;

function main(): int {
    $value = add(1, '2');

    $value
}
"#,
        ),
        Source::new(
            SourceKind::Script,
            "vendor/some-vendor/some-lib/src/add.ara",
            r#"
namespace Math;

function add(int $a, int $b): int {
    return $a + $b;
}
"#,
        ),
    ]);

    let report = Report::new().with_issue(
        Issue::error("", "mismatched types expected `{int}`, found `{string}`")
            .with_source("src/main.ara", 68, 71)
            .with_annotation(
                Annotation::secondary("src/main.ara", 61, 64)
                    .with_message("arguments to this function are incorrect"),
            )
            .with_annotation(
                Annotation::secondary("vendor/some-vendor/some-lib/src/add.ara", 27, 51)
                    .with_message("function defined here"),
            )
            .with_note(
                "you can cast a `{string}` to an `{int}` using `Psl\\Str\\to_int(...)` function",
            ),
    );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
More examples
Hide additional examples
examples/compact.rs (lines 41-55)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![
        Source::new(
            SourceKind::Script,
            "src/main.ara",
            r#"
use function Math\add;

function main(): int {
    $value = add(1, '2');

    $value
}
"#,
        ),
        Source::new(
            SourceKind::Script,
            "vendor/some-vendor/some-lib/src/add.ara",
            r#"
namespace Math;

function add(int $a, int $b): int {
    return $a + $b;
}
"#,
        ),
    ]);

    let report = Report::new().with_issue(
        Issue::error("", "mismatched types expected `{int}`, found `{string}`")
            .with_source("src/main.ara", 68, 71)
            .with_annotation(
                Annotation::secondary("src/main.ara", 61, 64)
                    .with_message("arguments to this function are incorrect"),
            )
            .with_annotation(
                Annotation::secondary("vendor/some-vendor/some-lib/src/add.ara", 27, 51)
                    .with_message("function defined here"),
            )
            .with_note(
                "you can cast a `{string}` to an `{int}` using `Psl\\Str\\to_int(...)` function",
            ),
    );

    let builder = ReportBuilder::new(&map)
        .with_charset(CharSet::Unicode)
        .with_colors(ColorChoice::Always)
        .with_style(DisplayStyle::Compact);

    builder.print(&report)
}
examples/comfortable.rs (lines 41-55)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![
        Source::new(
            SourceKind::Script,
            "src/main.ara",
            r#"
use function Math\add;

function main(): int {
    $value = add(1, '2');

    $value
}
"#,
        ),
        Source::new(
            SourceKind::Script,
            "vendor/some-vendor/some-lib/src/add.ara",
            r#"
namespace Math;

function add(int $a, int $b): int {
    return $a + $b;
}
"#,
        ),
    ]);

    let report = Report::new().with_issue(
        Issue::error("", "mismatched types expected `{int}`, found `{string}`")
            .with_source("src/main.ara", 68, 71)
            .with_annotation(
                Annotation::secondary("src/main.ara", 61, 64)
                    .with_message("arguments to this function are incorrect"),
            )
            .with_annotation(
                Annotation::secondary("vendor/some-vendor/some-lib/src/add.ara", 27, 51)
                    .with_message("function defined here"),
            )
            .with_note(
                "you can cast a `{string}` to an `{int}` using `Psl\\Str\\to_int(...)` function",
            ),
    );

    let builder = ReportBuilder::new(&map)
        .with_charset(CharSet::Unicode)
        .with_colors(ColorChoice::Always)
        .with_style(DisplayStyle::Comfortable);

    builder.print(&report)
}
examples/simple.rs (lines 26-42)
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

fn main() -> Result<(), Error> {
    let origin = "example.ara";
    let code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let map = SourceMap::new(vec![Source::new(SourceKind::Script, origin, code)]);

    let report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
examples/collection.rs (lines 35-51)
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

fn main() -> Result<(), Error> {
    let first_origin = "example.ara";
    let first_code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let second_origin = "example-2.ara";
    let second_code = r#"
function foo(Bar&float) {}
"#;

    let map = SourceMap::new(vec![
        Source::new(SourceKind::Script, first_origin, first_code),
        Source::new(SourceKind::Script, second_origin, second_code),
    ]);

    let first_report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(first_origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(first_origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let second_report = Report::new()
        .with_issue(
            Issue::error(
                "P0015",
                "scalar type `float` cannot be used in an intersection",
            )
            .with_source(second_origin, 18, 23)
            .with_annotation(
                Annotation::secondary(second_origin, 17, 19)
                    .with_message("scalar type `float` cannot be used in an intersection"),
            )
            .with_note("a scalar type is either `int`, `float`, `string`, or `bool`.")
            .with_note("try using a different type for the intersection."),
        )
        .with_issue(Issue::bug("B0001", "failed to read the file"))
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let reports: ReportCollection = vec![&first_report, &second_report];

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&reports)
}
examples/example.rs (lines 36-43)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![Source::inline(
        SourceKind::Script,
        r#"
function main(): int|string {
    $a = 1;
    $b = 2;

    $c = $a + $b;

    $b = match ($a) {
        1 => 2,
        2 => 3,
        default => "string",
    };

    return $c + $b;
}
"#,
    )]);

    let report = Report::new()
        .with_issue(
            Issue::error("E123", "some error here")
                .with_source(DEFAULT_NAME, 35, 41)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 41, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W123", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W124", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::note("N123", "some note here")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 105, 112).with_message("an annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 121, 128)
                        .with_message("another annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 137, 147).with_message("and another"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::help("H123", "some help here")
                .with_source(DEFAULT_NAME, 137, 147)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 35, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::bug("E123", "`match` arms have incompatible types")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 110, 111)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 148, 156)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0308`"),
        )
        .with_footer(ReportFooter::new("this is a report footer message"));

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}

Add a footer to this report.

Examples found in repository?
examples/simple.rs (lines 43-46)
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

fn main() -> Result<(), Error> {
    let origin = "example.ara";
    let code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let map = SourceMap::new(vec![Source::new(SourceKind::Script, origin, code)]);

    let report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
More examples
Hide additional examples
examples/collection.rs (lines 52-55)
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

fn main() -> Result<(), Error> {
    let first_origin = "example.ara";
    let first_code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let second_origin = "example-2.ara";
    let second_code = r#"
function foo(Bar&float) {}
"#;

    let map = SourceMap::new(vec![
        Source::new(SourceKind::Script, first_origin, first_code),
        Source::new(SourceKind::Script, second_origin, second_code),
    ]);

    let first_report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(first_origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(first_origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let second_report = Report::new()
        .with_issue(
            Issue::error(
                "P0015",
                "scalar type `float` cannot be used in an intersection",
            )
            .with_source(second_origin, 18, 23)
            .with_annotation(
                Annotation::secondary(second_origin, 17, 19)
                    .with_message("scalar type `float` cannot be used in an intersection"),
            )
            .with_note("a scalar type is either `int`, `float`, `string`, or `bool`.")
            .with_note("try using a different type for the intersection."),
        )
        .with_issue(Issue::bug("B0001", "failed to read the file"))
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let reports: ReportCollection = vec![&first_report, &second_report];

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&reports)
}
examples/example.rs (line 100)
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

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![Source::inline(
        SourceKind::Script,
        r#"
function main(): int|string {
    $a = 1;
    $b = 2;

    $c = $a + $b;

    $b = match ($a) {
        1 => 2,
        2 => 3,
        default => "string",
    };

    return $c + $b;
}
"#,
    )]);

    let report = Report::new()
        .with_issue(
            Issue::error("E123", "some error here")
                .with_source(DEFAULT_NAME, 35, 41)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 41, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W123", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W124", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::note("N123", "some note here")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 105, 112).with_message("an annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 121, 128)
                        .with_message("another annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 137, 147).with_message("and another"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::help("H123", "some help here")
                .with_source(DEFAULT_NAME, 137, 147)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 35, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::bug("E123", "`match` arms have incompatible types")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 110, 111)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 148, 156)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0308`"),
        )
        .with_footer(ReportFooter::new("this is a report footer message"));

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}
source

pub fn severity(&self) -> Option<IssueSeverity>

Returns the highest severity of all issues in this report.

Example:

use ara_reporting::Report;
use ara_reporting::issue::Issue;
use ara_reporting::issue::IssueSeverity;

let empty_report = Report::new();

let first_report = Report::new()
    .with_issue(Issue::help("0001", "...").with_source("main.ara", 10, 11))
    .with_issue(Issue::warning("0002", "...").with_source("some_file.ara", 9, 10))
    .with_issue(Issue::note("0003", "...").with_source("main.ara", 10, 11));

let second_report = Report::new()
    .with_issue(Issue::warning("0001", "...").with_source("some_file.ara", 9, 10))
    .with_issue(Issue::bug("0002", "...").with_source("main.ara", 10, 11))
    .with_issue(Issue::error("0003", "...").with_source("main.ara", 10, 11));

let third_report = Report::new()
    .with_issue(Issue::help("0001", "...").with_source("main.ara", 10, 11))
    .with_issue(Issue::note("0002", "...").with_source("main.ara", 10, 11))
    .with_issue(Issue::note("0003", "...").with_source("main.ara", 10, 11));

assert_eq!(empty_report.severity(), None);
assert_eq!(first_report.severity().unwrap(), IssueSeverity::Warning);
assert_eq!(second_report.severity().unwrap(), IssueSeverity::Bug);
assert_eq!(third_report.severity().unwrap(), IssueSeverity::Help);

Trait Implementations§

source§

impl Clone for Report

source§

fn clone(&self) -> Report

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Report

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Report

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Report

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Display for Report

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl From<Issue> for Report

source§

fn from(val: Issue) -> Self

Converts to this type from the input type.
source§

impl JsonSchema for Report

source§

fn schema_name() -> String

The name of the generated JSON Schema. Read more
source§

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type. Read more
source§

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword. Read more
source§

impl PartialEq<Report> for Report

source§

fn eq(&self, other: &Report) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Reportable for Report

source§

fn to_reports(&self) -> Vec<&Report>

source§

impl Serialize for Report

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl Eq for Report

source§

impl StructuralEq for Report

source§

impl StructuralPartialEq for Report

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere
    T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere
    T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere
    T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> DynClone for Twhere
    T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<!> for T

const: unstable · source§

fn from(t: !) -> T

Converts to this type from the input type.
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere
    U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for Twhere
    T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere
    T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere
    U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere
    U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> DeserializeOwned for Twhere
    T: for<'de> Deserialize<'de>,