elba 0.3.0

elba is a package manager for Idris
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Utilities for interacting with the Idris compiler

use crate::{
    build::context::BuildContext,
    retrieve::cache::{Binary, OutputLayout},
    util::{errors::Res, fmt_output},
};
use failure::bail;
use itertools::Itertools;
use std::{
    path::{Path, PathBuf},
    process::Output,
};

// CompileInvocation is responsible for dealing with ibc stuff
#[derive(Debug)]
pub struct CompileInvocation<'a> {
    pub deps: &'a [&'a Binary],
    pub targets: &'a [PathBuf],
    pub build: &'a Path,
    pub args: &'a [String],
}

impl<'a> CompileInvocation<'a> {
    pub fn exec(&self, bcx: &BuildContext) -> Res<Output> {
        // invoke compiler
        let mut process = bcx.compiler.process();
        let flavor = bcx.compiler.flavor();
        process.current_dir(&self.build).arg("--check");

        // Include dependencies
        if flavor.is_idris1() {
            for binary in self.deps {
                // We assume that the binary has already been compiled
                process.arg("-i").arg(binary.target.path());
            }
        } else {
            process.env(
                "BLODWEN_PATH",
                self.deps
                    .iter()
                    .map(|x| x.target.path().to_string_lossy())
                    .join(":"),
            );
        }

        process.args(self.args);

        // Add compile units: the individual files that we want to "export" and make available
        for target in self.targets {
            process.arg(target);
        }

        // The moment of truth:
        let res = process.output()?;
        if !res.status.success() {
            bail!("> {:#?}\n{}", process, fmt_output(&res))
        }

        Ok(res)
    }
}

// If we want to create something with output from a codegen backend (either a library or a binary)
// we look to CodegenInvocation.
#[derive(Debug)]
pub struct CodegenInvocation<'a> {
    pub binary: &'a [PathBuf],
    pub output: &'a str,
    pub layout: &'a OutputLayout,
    /// Whether the output should be treated as a binary (false) or artifact files (true)
    pub is_artifact: bool,
    pub args: &'a [String],
}

impl<'a> CodegenInvocation<'a> {
    pub fn exec(self, bcx: &BuildContext) -> Res<Output> {
        // Invoke the compiler.
        let mut process = bcx.compiler.process();
        let flavor = bcx.compiler.flavor();
        let cwd;

        if self.is_artifact {
            if flavor.is_idris1() {
                process.arg("--interface");
            } else {
                bail!("Only the Idris 1 compiler supports library artifacts")
            }
        }

        process
            .current_dir(if self.is_artifact {
                cwd = self.layout.artifacts.join(&bcx.backend.name);
                &cwd
            } else {
                &self.layout.bin
            })
            .args(&["-o", &self.output])
            .args(&[
                if bcx.backend.portable && flavor.is_idris1() {
                    "--portable-codegen"
                } else {
                    "--codegen"
                },
                &bcx.backend.name,
            ]);

        if !bcx.backend.opts.is_empty() && flavor.is_idris1() {
            process
                .arg("--cg-opt")
                .arg(bcx.backend.opts.iter().join(" "));
        }

        process.args(self.args);

        for bin in self.binary {
            if flavor.is_idris1() {
                process.arg("-i");
                process.arg(bin.parent().unwrap());
            }
            process.arg(bin);
        }

        if flavor.is_idris2() {
            process.env(
                "BLODWEN_PATH",
                self.binary
                    .iter()
                    .map(|x| x.parent().unwrap().to_string_lossy())
                    .join(":"),
            );

            for bin in self.binary {
                process.arg(bin);
            }
        }

        let res = process.output()?;
        // The Idris compiler is stupid, and won't output a non-zero error code if there's no main
        // function in the file, so we manually check if stdout contains a "main not found" error.
        let stdout = String::from_utf8_lossy(&res.stdout);

        if stdout.contains("No such variable Main.main") || !res.status.success() {
            bail!("> {:#?}\n{}", process, fmt_output(&res))
        }

        Ok(res)
    }
}