extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-03-24 21:47:56 +01:00
Code Issues Packages Projects Releases Wiki Activity
1ad9d6f199
nushell/src/errors.rs

685 lines
21 KiB
Rust
Raw Normal View History

Internals cleanup and | select ...fields
2019-05-15 20:14:51 +02:00
use crate::prelude::*;
WIP
2019-06-22 05:43:37 +02:00
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
use crate::parser::parse::parser::TracableContext;
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
use ansi_term::Color;
objectshell initial commit
2019-05-10 18:59:12 +02:00
use derive_new::new;
Add pretty errors to commands
2019-06-08 00:35:07 +02:00
use language_reporting::{Diagnostic, Label, Severity};
"Add plugin arg errors. Bring remaining errors to parity"
2019-07-13 18:59:59 +02:00
use serde::{Deserialize, Serialize};
Add support for ~ expansion This ended up being a bit of a yak shave. The basic idea in this commit is to expand `~` in paths, but only in paths. The way this is accomplished is by doing the expansion inside of the code that parses literal syntax for `SyntaxType::Path`. As a quick refresher: every command is entitled to expand its arguments in a custom way. While this could in theory be used for general-purpose macros, today the expansion facility is limited to syntactic hints. For example, the syntax `where cpu > 0` expands under the hood to `where { $it.cpu > 0 }`. This happens because the first argument to `where` is defined as a `SyntaxType::Block`, and the parser coerces binary expressions whose left-hand-side looks like a member into a block when the command is expecting one. This is mildly more magical than what most programming languages would do, but we believe that it makes sense to allow commands to fine-tune the syntax because of the domain nushell is in (command-line shells). The syntactic expansions supported by this facility are relatively limited. For example, we don't allow `$it` to become a bare word, simply because the command asks for a string in the relevant position. That would quickly become more confusing than it's worth. This PR adds a new `SyntaxType` rule: `SyntaxType::Path`. When a command declares a parameter as a `SyntaxType::Path`, string literals and bare words passed as an argument to that parameter are processed using the path expansion rules. Right now, that only means that `~` is expanded into the home directory, but additional rules are possible in the future. By restricting this expansion to a syntactic expansion when passed as an argument to a command expecting a path, we avoid making `~` a generally reserved character. This will also allow us to give good tab completion for paths with `~` characters in them when a command is expecting a path. In order to accomplish the above, this commit changes the parsing functions to take a `Context` instead of just a `CommandRegistry`. From the perspective of macro expansion, you can think of the `CommandRegistry` as a dictionary of in-scope macros, and the `Context` as the compile-time state used in expansion. This could gain additional functionality over time as we find more uses for the expansion system.
2019-08-26 21:21:03 +02:00
use std::fmt;
objectshell initial commit
2019-05-10 18:59:12 +02:00
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Serialize, Deserialize)]
pub enum Description {
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
Source(Tagged<String>),
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
Synthetic(String),
}
impl Description {
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
fn into_label(self) -> Result<Label<Tag>, String> {
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
match self {
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
Description::Source(s) => Ok(Label::new_primary(s.tag()).with_message(s.item)),
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
Description::Synthetic(s) => Err(s),
}
}
}
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Serialize, Deserialize)]
pub enum ArgumentError {
MissingMandatoryFlag(String),
MissingMandatoryPositional(String),
MissingValueForName(String),
Close a bunch of holes in external command args Previously, there was a single parsing rule for "bare words" that applied to both internal and external commands. This meant that, because `cargo +nightly` needed to work, we needed to add `+` as a valid character in bare words. The number of characters continued to grow, and the situation was becoming untenable. The current strategy would eventually eat up all syntax and make it impossible to add syntax like `@foo` to internal commands. This patch significantly restricts bare words and introduces a new token type (`ExternalWord`). An `ExternalWord` expands to an error in the internal syntax, but expands to a bare word in the external syntax. `ExternalWords` are highlighted in grey in the shell.
2019-09-09 19:43:10 +02:00
InvalidExternalWord,
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
}
Improve signature infrastructure The `config` command uses different kinds of named arguments, which illustrates how it works.
2019-06-01 07:50:16 +02:00
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Serialize, Deserialize)]
Tests pass
2019-07-09 06:31:26 +02:00
pub struct ShellError {
error: ProximateShellError,
cause: Option<Box<ProximateShellError>>,
A bunch of rework I'm gonna use a VecDeque now instead of trying to get async streams working to make progress, but the intent is that we should be able to use async streams in and out to interleave the work better.
2019-05-13 19:30:51 +02:00
}
Add support for ~ expansion This ended up being a bit of a yak shave. The basic idea in this commit is to expand `~` in paths, but only in paths. The way this is accomplished is by doing the expansion inside of the code that parses literal syntax for `SyntaxType::Path`. As a quick refresher: every command is entitled to expand its arguments in a custom way. While this could in theory be used for general-purpose macros, today the expansion facility is limited to syntactic hints. For example, the syntax `where cpu > 0` expands under the hood to `where { $it.cpu > 0 }`. This happens because the first argument to `where` is defined as a `SyntaxType::Block`, and the parser coerces binary expressions whose left-hand-side looks like a member into a block when the command is expecting one. This is mildly more magical than what most programming languages would do, but we believe that it makes sense to allow commands to fine-tune the syntax because of the domain nushell is in (command-line shells). The syntactic expansions supported by this facility are relatively limited. For example, we don't allow `$it` to become a bare word, simply because the command asks for a string in the relevant position. That would quickly become more confusing than it's worth. This PR adds a new `SyntaxType` rule: `SyntaxType::Path`. When a command declares a parameter as a `SyntaxType::Path`, string literals and bare words passed as an argument to that parameter are processed using the path expansion rules. Right now, that only means that `~` is expanded into the home directory, but additional rules are possible in the future. By restricting this expansion to a syntactic expansion when passed as an argument to a command expecting a path, we avoid making `~` a generally reserved character. This will also allow us to give good tab completion for paths with `~` characters in them when a command is expecting a path. In order to accomplish the above, this commit changes the parsing functions to take a `Context` instead of just a `CommandRegistry`. From the perspective of macro expansion, you can think of the `CommandRegistry` as a dictionary of in-scope macros, and the `Context` as the compile-time state used in expansion. This could gain additional functionality over time as we find more uses for the expansion system.
2019-08-26 21:21:03 +02:00
impl ToDebug for ShellError {
fn fmt_debug(&self, f: &mut fmt::Formatter, source: &str) -> fmt::Result {
self.error.fmt_debug(f, source)
}
}
Restructuring
2019-08-02 21:15:07 +02:00
impl serde::de::Error for ShellError {
fn custom<T>(msg: T) -> Self
where
T: std::fmt::Display,
{
ShellError::string(msg.to_string())
}
}
A bunch of rework I'm gonna use a VecDeque now instead of trying to get async streams working to make progress, but the intent is that we should be able to use async streams in and out to interleave the work better.
2019-05-13 19:30:51 +02:00
impl ShellError {
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn type_error(
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
expected: impl Into<String>,
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
actual: Tagged<impl Into<String>>,
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
) -> ShellError {
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::TypeError {
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
expected: expected.into(),
actual: actual.map(|i| Some(i.into())),
}
Tests pass
2019-07-09 06:31:26 +02:00
.start()
}
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
pub(crate) fn unexpected_eof(expected: impl Into<String>, tag: Tag) -> ShellError {
ProximateShellError::UnexpectedEof {
expected: expected.into(),
tag,
}
.start()
}
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
pub(crate) fn range_error(
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
expected: impl Into<ExpectedRange>,
actual: &Tagged<impl fmt::Debug>,
operation: String,
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
) -> ShellError {
ProximateShellError::RangeError {
kind: expected.into(),
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
actual_kind: actual.copy_tag(format!("{:?}", actual.item)),
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
operation,
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
}
.start()
}
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn syntax_error(problem: Tagged<impl Into<String>>) -> ShellError {
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
ProximateShellError::SyntaxError {
problem: problem.map(|p| p.into()),
}
.start()
}
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
#[allow(unused)]
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn invalid_command(problem: impl Into<Tag>) -> ShellError {
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
ProximateShellError::InvalidCommand {
command: problem.into(),
}
.start()
}
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn coerce_error(
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
left: Tagged<impl Into<String>>,
right: Tagged<impl Into<String>>,
Tests pass
2019-07-09 06:31:26 +02:00
) -> ShellError {
ProximateShellError::CoerceError {
left: left.map(|l| l.into()),
right: right.map(|r| r.into()),
}
.start()
}
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
pub(crate) fn missing_value(tag: Option<Tag>, reason: impl Into<String>) -> ShellError {
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
ProximateShellError::MissingValue {
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag,
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
reason: reason.into(),
}
.start()
}
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn argument_error(
Tests pass
2019-07-09 06:31:26 +02:00
command: impl Into<String>,
kind: ArgumentError,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag: Tag,
Tests pass
2019-07-09 06:31:26 +02:00
) -> ShellError {
ProximateShellError::ArgumentError {
command: command.into(),
error: kind,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag,
Tests pass
2019-07-09 06:31:26 +02:00
}
.start()
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
}
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
pub(crate) fn invalid_external_word(tag: Tag) -> ShellError {
Close a bunch of holes in external command args Previously, there was a single parsing rule for "bare words" that applied to both internal and external commands. This meant that, because `cargo +nightly` needed to work, we needed to add `+` as a valid character in bare words. The number of characters continued to grow, and the situation was becoming untenable. The current strategy would eventually eat up all syntax and make it impossible to add syntax like `@foo` to internal commands. This patch significantly restricts bare words and introduces a new token type (`ExternalWord`). An `ExternalWord` expands to an error in the internal syntax, but expands to a bare word in the external syntax. `ExternalWords` are highlighted in grey in the shell.
2019-09-09 19:43:10 +02:00
ProximateShellError::ArgumentError {
command: "Invalid argument to Nu command (did you mean to call an external command?)"
.into(),
error: ArgumentError::InvalidExternalWord,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag,
Close a bunch of holes in external command args Previously, there was a single parsing rule for "bare words" that applied to both internal and external commands. This meant that, because `cargo +nightly` needed to work, we needed to add `+` as a valid character in bare words. The number of characters continued to grow, and the situation was becoming untenable. The current strategy would eventually eat up all syntax and make it impossible to add syntax like `@foo` to internal commands. This patch significantly restricts bare words and introduces a new token type (`ExternalWord`). An `ExternalWord` expands to an error in the internal syntax, but expands to a bare word in the external syntax. `ExternalWords` are highlighted in grey in the shell.
2019-09-09 19:43:10 +02:00
}
.start()
}
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn parse_error(
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
error: nom::Err<(
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
nom_locate::LocatedSpanEx<&str, TracableContext>,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
nom::error::ErrorKind,
)>,
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
) -> ShellError {
use language_reporting::*;
match error {
Remove unwraps from the parser I intend to add regression tests for these cases to the parser as a follow-up PR. Fixes #490 Fixes #494
2019-08-27 23:20:18 +02:00
nom::Err::Incomplete(_) => {
// TODO: Get span of EOF
let diagnostic = Diagnostic::new(
Severity::Error,
format!("Parse Error: Unexpected end of line"),
);
ShellError::diagnostic(diagnostic)
}
WIP
2019-06-22 05:43:37 +02:00
nom::Err::Failure(span) | nom::Err::Error(span) => {
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
let diagnostic = Diagnostic::new(Severity::Error, format!("Parse Error"))
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(Tag::from(span.0)));
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
Add pretty errors to commands
2019-06-08 00:35:07 +02:00
ShellError::diagnostic(diagnostic)
Tests pass
2019-07-09 06:31:26 +02:00
}
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
}
}
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
pub(crate) fn diagnostic(diagnostic: Diagnostic<Tag>) -> ShellError {
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::Diagnostic(ShellDiagnostic { diagnostic }).start()
Add pretty errors to commands
2019-06-08 00:35:07 +02:00
}
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
pub(crate) fn to_diagnostic(self) -> Diagnostic<Tag> {
Tests pass
2019-07-09 06:31:26 +02:00
match self.error {
ProximateShellError::String(StringError { title, .. }) => {
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
Diagnostic::new(Severity::Error, title)
}
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
ProximateShellError::InvalidCommand { command } => {
Diagnostic::new(Severity::Error, "Invalid command")
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(command))
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
}
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
ProximateShellError::MissingValue { tag, reason } => {
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
let mut d = Diagnostic::new(
Severity::Bug,
format!("Internal Error (missing value) :: {}", reason),
);
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
if let Some(tag) = tag {
d = d.with_label(Label::new_primary(tag));
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
}
d
}
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::ArgumentError {
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
command,
error,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag,
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
} => match error {
Close a bunch of holes in external command args Previously, there was a single parsing rule for "bare words" that applied to both internal and external commands. This meant that, because `cargo +nightly` needed to work, we needed to add `+` as a valid character in bare words. The number of characters continued to grow, and the situation was becoming untenable. The current strategy would eventually eat up all syntax and make it impossible to add syntax like `@foo` to internal commands. This patch significantly restricts bare words and introduces a new token type (`ExternalWord`). An `ExternalWord` expands to an error in the internal syntax, but expands to a bare word in the external syntax. `ExternalWords` are highlighted in grey in the shell.
2019-09-09 19:43:10 +02:00
ArgumentError::InvalidExternalWord => Diagnostic::new(
Severity::Error,
format!("Invalid bare word for Nu command (did you intend to invoke an external command?)"))
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(tag)),
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
ArgumentError::MissingMandatoryFlag(name) => Diagnostic::new(
Severity::Error,
format!(
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
"{} requires {}{}",
Color::Cyan.paint(command),
Color::Black.bold().paint("--"),
Color::Black.bold().paint(name)
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
),
)
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(tag)),
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
ArgumentError::MissingMandatoryPositional(name) => Diagnostic::new(
Severity::Error,
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
format!(
Finish updating the last cases
2019-08-20 08:11:11 +02:00
"{} requires {} parameter",
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
Color::Cyan.paint(command),
Finish updating the last cases
2019-08-20 08:11:11 +02:00
Color::Green.bold().paint(name.clone())
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
),
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
)
Finish updating the last cases
2019-08-20 08:11:11 +02:00
.with_label(
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
Label::new_primary(tag).with_message(format!("requires {} parameter", name)),
Finish updating the last cases
2019-08-20 08:11:11 +02:00
),
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
ArgumentError::MissingValueForName(name) => Diagnostic::new(
Severity::Error,
format!(
WIP improve error infrastructure Also simplify commands and reduce papercuts
2019-07-03 22:31:15 +02:00
"{} is missing value for flag {}{}",
Color::Cyan.paint(command),
Color::Black.bold().paint("--"),
Color::Black.bold().paint(name)
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
),
)
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(tag)),
Produce ArgumentError for signature mismatch ArgumentError also automatically produces diagnostics
2019-06-30 08:14:40 +02:00
},
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::TypeError {
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
expected,
actual:
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
Tagged {
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
item: Some(actual),
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag,
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
},
} => Diagnostic::new(Severity::Error, "Type Error").with_label(
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
Label::new_primary(tag)
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
.with_message(format!("Expected {}, found {}", expected, actual)),
),
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::TypeError {
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
expected,
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
actual:
Tagged {
item: None,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
},
Support evaluating most expressions Blocks, paths, and others Plus a bunch of other infra improvements
2019-06-29 10:55:42 +02:00
} => Diagnostic::new(Severity::Error, "Type Error")
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(tag).with_message(expected)),
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
ProximateShellError::UnexpectedEof {
expected, tag
} => Diagnostic::new(Severity::Error, format!("Unexpected end of input"))
.with_label(Label::new_primary(tag).with_message(format!("Expected {}", expected))),
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
ProximateShellError::RangeError {
kind,
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
operation,
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
actual_kind:
Tagged {
item,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
},
} => Diagnostic::new(Severity::Error, "Range Error").with_label(
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
Label::new_primary(tag).with_message(format!(
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
"Expected to convert {} to {} while {}, but it was out of range",
item,
kind.desc(),
operation
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
)),
),
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
ProximateShellError::SyntaxError {
problem:
Tagged {
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag,
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
item
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
},
} => Diagnostic::new(Severity::Error, "Syntax Error")
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
.with_label(Label::new_primary(tag).with_message(item)),
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::MissingProperty { subpath, expr } => {
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
let subpath = subpath.into_label();
let expr = expr.into_label();
let mut diag = Diagnostic::new(Severity::Error, "Missing property");
match subpath {
Ok(label) => diag = diag.with_label(label),
Err(ty) => diag.message = format!("Missing property (for {})", ty),
}
if let Ok(label) = expr {
Revert "Heuristic table view"
2019-08-15 18:49:07 +02:00
diag = diag.with_label(label);
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
}
diag
}
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::Diagnostic(diag) => diag.diagnostic,
ProximateShellError::CoerceError { left, right } => {
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
Diagnostic::new(Severity::Error, "Coercion error")
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(left.tag()).with_message(left.item))
.with_label(Label::new_secondary(right.tag()).with_message(right.item))
Fix a bunch of bugs
2019-06-24 02:55:31 +02:00
}
}
}
"Add plugin arg errors. Bring remaining errors to parity"
2019-07-13 18:59:59 +02:00
pub fn labeled_error(
Add pretty errors to commands
2019-06-08 00:35:07 +02:00
msg: impl Into<String>,
label: impl Into<String>,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag: impl Into<Tag>,
Add pretty errors to commands
2019-06-08 00:35:07 +02:00
) -> ShellError {
ShellError::diagnostic(
Diagnostic::new(Severity::Error, msg.into())
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
.with_label(Label::new_primary(tag.into()).with_message(label.into())),
Add pretty errors to commands
2019-06-08 00:35:07 +02:00
)
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
}
Move more parts to tags and away from spans
2019-08-05 10:54:29 +02:00
pub fn labeled_error_with_secondary(
Update errors and improve ctrl-c
2019-06-15 20:36:17 +02:00
msg: impl Into<String>,
Move more parts to tags and away from spans
2019-08-05 10:54:29 +02:00
primary_label: impl Into<String>,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
primary_span: impl Into<Tag>,
Move more parts to tags and away from spans
2019-08-05 10:54:29 +02:00
secondary_label: impl Into<String>,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
secondary_span: impl Into<Tag>,
Update errors and improve ctrl-c
2019-06-15 20:36:17 +02:00
) -> ShellError {
Move more parts to tags and away from spans
2019-08-05 10:54:29 +02:00
ShellError::diagnostic(
Diagnostic::new_error(msg.into())
.with_label(
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
Label::new_primary(primary_span.into()).with_message(primary_label.into()),
)
.with_label(
Label::new_secondary(secondary_span.into())
.with_message(secondary_label.into()),
Move more parts to tags and away from spans
2019-08-05 10:54:29 +02:00
),
)
Update errors and improve ctrl-c
2019-06-15 20:36:17 +02:00
}
First working plugin
2019-06-27 06:56:48 +02:00
pub fn string(title: impl Into<String>) -> ShellError {
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::String(StringError::new(title.into(), Value::nothing())).start()
A bunch of rework I'm gonna use a VecDeque now instead of trying to get async streams working to make progress, but the intent is that we should be able to use async streams in and out to interleave the work better.
2019-05-13 19:30:51 +02:00
}
Internals cleanup and | select ...fields
2019-05-15 20:14:51 +02:00
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn unimplemented(title: impl Into<String>) -> ShellError {
Improve parser
2019-06-04 23:42:31 +02:00
ShellError::string(&format!("Unimplemented: {}", title.into()))
}
Replace crate visibility identifier with pub(crate) Result of running: find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
2019-08-29 13:08:28 +02:00
pub(crate) fn unexpected(title: impl Into<String>) -> ShellError {
WIP
2019-06-22 05:43:37 +02:00
ShellError::string(&format!("Unexpected: {}", title.into()))
}
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
pub(crate) fn unreachable(title: impl Into<String>) -> ShellError {
ShellError::string(&format!("BUG: Unreachable: {}", title.into()))
}
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
}
Refactor the repl loop
2019-05-16 23:43:36 +02:00
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Serialize, Deserialize)]
pub enum ExpectedRange {
I8,
I16,
I32,
I64,
I128,
U8,
U16,
U32,
U64,
U128,
F32,
F64,
BigInt,
BigDecimal,
}
impl ExpectedRange {
fn desc(&self) -> &'static str {
match self {
ExpectedRange::I8 => "an 8-bit signed integer",
ExpectedRange::I16 => "a 16-bit signed integer",
ExpectedRange::I32 => "a 32-bit signed integer",
ExpectedRange::I64 => "a 64-bit signed integer",
ExpectedRange::I128 => "a 128-bit signed integer",
ExpectedRange::U8 => "an 8-bit unsigned integer",
ExpectedRange::U16 => "a 16-bit unsigned integer",
ExpectedRange::U32 => "a 32-bit unsigned integer",
ExpectedRange::U64 => "a 64-bit unsigned integer",
ExpectedRange::U128 => "a 128-bit unsigned integer",
ExpectedRange::F32 => "a 32-bit float",
ExpectedRange::F64 => "a 64-bit float",
ExpectedRange::BigDecimal => "a decimal",
ExpectedRange::BigInt => "an integer",
}
}
}
Tests pass
2019-07-09 06:31:26 +02:00
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Serialize, Deserialize)]
pub enum ProximateShellError {
String(StringError),
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
SyntaxError {
problem: Tagged<String>,
},
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
UnexpectedEof {
expected: String,
tag: Tag,
},
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
InvalidCommand {
command: Tag,
},
Tests pass
2019-07-09 06:31:26 +02:00
TypeError {
expected: String,
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
actual: Tagged<Option<String>>,
Tests pass
2019-07-09 06:31:26 +02:00
},
MissingProperty {
subpath: Description,
expr: Description,
},
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
MissingValue {
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag: Option<Tag>,
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
reason: String,
},
Tests pass
2019-07-09 06:31:26 +02:00
ArgumentError {
command: String,
error: ArgumentError,
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
tag: Tag,
Tests pass
2019-07-09 06:31:26 +02:00
},
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
RangeError {
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
kind: ExpectedRange,
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
actual_kind: Tagged<String>,
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
operation: String,
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
},
Tests pass
2019-07-09 06:31:26 +02:00
Diagnostic(ShellDiagnostic),
CoerceError {
initial change to Tagged<Value>
2019-08-01 03:58:42 +02:00
left: Tagged<String>,
right: Tagged<String>,
Tests pass
2019-07-09 06:31:26 +02:00
},
}
Add support for ~ expansion This ended up being a bit of a yak shave. The basic idea in this commit is to expand `~` in paths, but only in paths. The way this is accomplished is by doing the expansion inside of the code that parses literal syntax for `SyntaxType::Path`. As a quick refresher: every command is entitled to expand its arguments in a custom way. While this could in theory be used for general-purpose macros, today the expansion facility is limited to syntactic hints. For example, the syntax `where cpu > 0` expands under the hood to `where { $it.cpu > 0 }`. This happens because the first argument to `where` is defined as a `SyntaxType::Block`, and the parser coerces binary expressions whose left-hand-side looks like a member into a block when the command is expecting one. This is mildly more magical than what most programming languages would do, but we believe that it makes sense to allow commands to fine-tune the syntax because of the domain nushell is in (command-line shells). The syntactic expansions supported by this facility are relatively limited. For example, we don't allow `$it` to become a bare word, simply because the command asks for a string in the relevant position. That would quickly become more confusing than it's worth. This PR adds a new `SyntaxType` rule: `SyntaxType::Path`. When a command declares a parameter as a `SyntaxType::Path`, string literals and bare words passed as an argument to that parameter are processed using the path expansion rules. Right now, that only means that `~` is expanded into the home directory, but additional rules are possible in the future. By restricting this expansion to a syntactic expansion when passed as an argument to a command expecting a path, we avoid making `~` a generally reserved character. This will also allow us to give good tab completion for paths with `~` characters in them when a command is expecting a path. In order to accomplish the above, this commit changes the parsing functions to take a `Context` instead of just a `CommandRegistry`. From the perspective of macro expansion, you can think of the `CommandRegistry` as a dictionary of in-scope macros, and the `Context` as the compile-time state used in expansion. This could gain additional functionality over time as we find more uses for the expansion system.
2019-08-26 21:21:03 +02:00
Tests pass
2019-07-09 06:31:26 +02:00
impl ProximateShellError {
fn start(self) -> ShellError {
ShellError {
cause: None,
error: self,
}
}
}
Add support for ~ expansion This ended up being a bit of a yak shave. The basic idea in this commit is to expand `~` in paths, but only in paths. The way this is accomplished is by doing the expansion inside of the code that parses literal syntax for `SyntaxType::Path`. As a quick refresher: every command is entitled to expand its arguments in a custom way. While this could in theory be used for general-purpose macros, today the expansion facility is limited to syntactic hints. For example, the syntax `where cpu > 0` expands under the hood to `where { $it.cpu > 0 }`. This happens because the first argument to `where` is defined as a `SyntaxType::Block`, and the parser coerces binary expressions whose left-hand-side looks like a member into a block when the command is expecting one. This is mildly more magical than what most programming languages would do, but we believe that it makes sense to allow commands to fine-tune the syntax because of the domain nushell is in (command-line shells). The syntactic expansions supported by this facility are relatively limited. For example, we don't allow `$it` to become a bare word, simply because the command asks for a string in the relevant position. That would quickly become more confusing than it's worth. This PR adds a new `SyntaxType` rule: `SyntaxType::Path`. When a command declares a parameter as a `SyntaxType::Path`, string literals and bare words passed as an argument to that parameter are processed using the path expansion rules. Right now, that only means that `~` is expanded into the home directory, but additional rules are possible in the future. By restricting this expansion to a syntactic expansion when passed as an argument to a command expecting a path, we avoid making `~` a generally reserved character. This will also allow us to give good tab completion for paths with `~` characters in them when a command is expecting a path. In order to accomplish the above, this commit changes the parsing functions to take a `Context` instead of just a `CommandRegistry`. From the perspective of macro expansion, you can think of the `CommandRegistry` as a dictionary of in-scope macros, and the `Context` as the compile-time state used in expansion. This could gain additional functionality over time as we find more uses for the expansion system.
2019-08-26 21:21:03 +02:00
impl ToDebug for ProximateShellError {
fn fmt_debug(&self, f: &mut fmt::Formatter, _source: &str) -> fmt::Result {
// TODO: Custom debug for inner spans
write!(f, "{:?}", self)
}
}
"Add plugin arg errors. Bring remaining errors to parity"
2019-07-13 18:59:59 +02:00
#[derive(Debug, Clone, Serialize, Deserialize)]
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
pub struct ShellDiagnostic {
Revert "Revert "Migrate most uses of the Span concept to Tag"" This reverts commit bee7c5639cc78d65e6656518627a86009a522500.
2019-09-14 18:30:24 +02:00
pub(crate) diagnostic: Diagnostic<Tag>,
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
}
impl PartialEq for ShellDiagnostic {
fn eq(&self, _other: &ShellDiagnostic) -> bool {
false
Refactor the repl loop
2019-05-16 23:43:36 +02:00
}
objectshell initial commit
2019-05-10 18:59:12 +02:00
}
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
impl Eq for ShellDiagnostic {}
impl std::cmp::PartialOrd for ShellDiagnostic {
fn partial_cmp(&self, _other: &Self) -> Option<std::cmp::Ordering> {
Some(std::cmp::Ordering::Less)
}
}
impl std::cmp::Ord for ShellDiagnostic {
fn cmp(&self, _other: &Self) -> std::cmp::Ordering {
std::cmp::Ordering::Less
}
}
Improve signature infrastructure The `config` command uses different kinds of named arguments, which illustrates how it works.
2019-06-01 07:50:16 +02:00
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, new, Clone, Serialize, Deserialize)]
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
pub struct StringError {
title: String,
error: Value,
}
objectshell initial commit
2019-05-10 18:59:12 +02:00
impl std::fmt::Display for ShellError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
Tests pass
2019-07-09 06:31:26 +02:00
match &self.error {
ProximateShellError::String(s) => write!(f, "{}", &s.title),
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
ProximateShellError::MissingValue { .. } => write!(f, "MissingValue"),
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
ProximateShellError::InvalidCommand { .. } => write!(f, "InvalidCommand"),
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::TypeError { .. } => write!(f, "TypeError"),
Overhaul the expansion system The main thrust of this (very large) commit is an overhaul of the expansion system. The parsing pipeline is: - Lightly parse the source file for atoms, basic delimiters and pipeline structure into a token tree - Expand the token tree into a HIR (high-level intermediate representation) based upon the baseline syntax rules for expressions and the syntactic shape of commands. Somewhat non-traditionally, nu doesn't have an AST at all. It goes directly from the token tree, which doesn't represent many important distinctions (like the difference between `hello` and `5KB`) directly into a high-level representation that doesn't have a direct correspondence to the source code. At a high level, nu commands work like macros, in the sense that the syntactic shape of the invocation of a command depends on the definition of a command. However, commands do not have the ability to perform unrestricted expansions of the token tree. Instead, they describe their arguments in terms of syntactic shapes, and the expander expands the token tree into HIR based upon that definition. For example, the `where` command says that it takes a block as its first required argument, and the description of the block syntactic shape expands the syntax `cpu > 10` into HIR that represents `{ $it.cpu > 10 }`. This commit overhauls that system so that the syntactic shapes are described in terms of a few new traits (`ExpandSyntax` and `ExpandExpression` are the primary ones) that are more composable than the previous system. The first big win of this new system is the addition of the `ColumnPath` shape, which looks like `cpu."max ghz"` or `package.version`. Previously, while a variable path could look like `$it.cpu."max ghz"`, the tail of a variable path could not be easily reused in other contexts. Now, that tail is its own syntactic shape, and it can be used as part of a command's signature. This cleans up commands like `inc`, `add` and `edit` as well as shorthand blocks, which can now look like `| where cpu."max ghz" > 10`
2019-09-18 00:26:27 +02:00
ProximateShellError::UnexpectedEof { .. } => write!(f, "UnexpectedEof"),
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
ProximateShellError::RangeError { .. } => write!(f, "RangeError"),
Add support for external escape valve (`^dir`) This commit makes it possible to force nu to treat a command as an external command by prefixing it with `^`. For example `^dir` will force `dir` to run an external command, even if `dir` is also a registered nu command. This ensures that users don't need to leave nu just because we happened to use a command they need. This commit adds a new token type for external commands, which, among other things, makes it pretty straight forward to syntax highlight external commands uniquely, and generally to treat them as special.
2019-08-16 00:18:18 +02:00
ProximateShellError::SyntaxError { .. } => write!(f, "SyntaxError"),
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::MissingProperty { .. } => write!(f, "MissingProperty"),
ProximateShellError::ArgumentError { .. } => write!(f, "ArgumentError"),
ProximateShellError::Diagnostic(_) => write!(f, "<diagnostic>"),
ProximateShellError::CoerceError { .. } => write!(f, "CoerceError"),
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
}
objectshell initial commit
2019-05-10 18:59:12 +02:00
}
}
impl std::error::Error for ShellError {}
Unwrap cleanup mitigation.
2019-08-21 14:08:23 +02:00
impl std::convert::From<Box<dyn std::error::Error>> for ShellError {
fn from(input: Box<dyn std::error::Error>) -> ShellError {
ProximateShellError::String(StringError {
title: format!("{}", input),
error: Value::nothing(),
})
.start()
}
}
objectshell initial commit
2019-05-10 18:59:12 +02:00
impl std::convert::From<std::io::Error> for ShellError {
fn from(input: std::io::Error) -> ShellError {
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::String(StringError {
objectshell initial commit
2019-05-10 18:59:12 +02:00
title: format!("{}", input),
A bunch of rework I'm gonna use a VecDeque now instead of trying to get async streams working to make progress, but the intent is that we should be able to use async streams in and out to interleave the work better.
2019-05-13 19:30:51 +02:00
error: Value::nothing(),
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
})
Tests pass
2019-07-09 06:31:26 +02:00
.start()
objectshell initial commit
2019-05-10 18:59:12 +02:00
}
}
Improved streams
2019-05-24 06:34:43 +02:00
Streams are wired up pairwise
2019-05-24 09:29:16 +02:00
impl std::convert::From<subprocess::PopenError> for ShellError {
fn from(input: subprocess::PopenError) -> ShellError {
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::String(StringError {
Streams are wired up pairwise
2019-05-24 09:29:16 +02:00
title: format!("{}", input),
error: Value::nothing(),
Better errors and more fleshed out semantics
2019-05-30 06:19:46 +02:00
})
Tests pass
2019-07-09 06:31:26 +02:00
.start()
Streams are wired up pairwise
2019-05-24 09:29:16 +02:00
}
}
A real parser (lalrpop)
2019-05-26 08:54:41 +02:00
Unwrap cleanup mitigation.
2019-08-21 14:08:23 +02:00
impl std::convert::From<serde_yaml::Error> for ShellError {
fn from(input: serde_yaml::Error) -> ShellError {
ProximateShellError::String(StringError {
title: format!("{:?}", input),
error: Value::nothing(),
})
.start()
}
}
Improve signature infrastructure The `config` command uses different kinds of named arguments, which illustrates how it works.
2019-06-01 07:50:16 +02:00
impl std::convert::From<toml::ser::Error> for ShellError {
fn from(input: toml::ser::Error) -> ShellError {
Tests pass
2019-07-09 06:31:26 +02:00
ProximateShellError::String(StringError {
Improve signature infrastructure The `config` command uses different kinds of named arguments, which illustrates how it works.
2019-06-01 07:50:16 +02:00
title: format!("{:?}", input),
error: Value::nothing(),
})
Tests pass
2019-07-09 06:31:26 +02:00
.start()
Improve signature infrastructure The `config` command uses different kinds of named arguments, which illustrates how it works.
2019-06-01 07:50:16 +02:00
}
}
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
impl std::convert::From<serde_json::Error> for ShellError {
fn from(input: serde_json::Error) -> ShellError {
ProximateShellError::String(StringError {
title: format!("{:?}", input),
error: Value::nothing(),
})
.start()
}
}
switch from reqwest to surf
2019-08-24 21:36:19 +02:00
impl std::convert::From<Box<dyn std::error::Error + Send + Sync>> for ShellError {
fn from(input: Box<dyn std::error::Error + Send + Sync>) -> ShellError {
ProximateShellError::String(StringError {
title: format!("{:?}", input),
error: Value::nothing(),
})
.start()
}
}
Reduce unwraps Remove a number of unwraps. In some cases, a `?` just worked as is. I also made it possible to use `?` to go from Result<OutputStream, ShellError> to OutputStream. Finally, started updating PerItemCommand to be able to use the signature deserialization logic, which substantially reduces unwraps. This is still in-progress work, but tests pass and it should be clear to merge and keep iterating on master.
2019-08-17 05:53:39 +02:00
pub trait ShellErrorUtils<T> {
fn unwrap_error(self, desc: impl Into<String>) -> Result<T, ShellError>;
}
impl<T> ShellErrorUtils<Tagged<T>> for Option<Tagged<T>> {
fn unwrap_error(self, desc: impl Into<String>) -> Result<Tagged<T>, ShellError> {
match self {
Some(value) => Ok(value),
None => Err(ShellError::missing_value(None, desc.into())),
}
}
}
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
pub trait CoerceInto<U> {
fn coerce_into(self, operation: impl Into<String>) -> Result<U, ShellError>;
Basic support for decimal numbers This commit is more substantial than it looks: there was basically no real support for decimals before, and that impacted values all the way through. I also made Size contain a decimal instead of an integer (`1.6kb` is a reasonable thing to type), which impacted a bunch of code. The biggest impact of this commit is that it creates many more possible ways for valid nu types to fail to serialize as toml, json, etc. which typically can't support the full range of Decimal (or Bigint, which I also think we should support). This commit makes to-toml fallible, and a similar effort is necessary for the rest of the serializations. We also need to figure out how to clearly communicate to users what has happened, but failing to serialize to toml seems clearly superior to me than weird errors in basic math operations.
2019-08-30 19:29:04 +02:00
}
Migrated numerics to BigInt/BigDecimal This commit migrates Value's numeric types to BigInt and BigDecimal. The basic idea is that overflow errors aren't great in a shell environment, and not really necessary. The main immediate consequence is that new errors can occur when serializing Nu values to other formats. You can see this in changes to the various serialization formats (JSON, TOML, etc.). There's a new `CoerceInto` trait that uses the `ToPrimitive` trait from `num_traits` to attempt to coerce a `BigNum` or `BigDecimal` into a target type, and produces a `RangeError` (kind of `ShellError`) if the coercion fails. Another possible future consequence is that certain performance-critical numeric operations might be too slow. If that happens, we can introduce specialized numeric types to help improve the performance of those situations, based on the real-world experience.
2019-09-01 18:20:31 +02:00
trait ToExpectedRange {
fn to_expected_range() -> ExpectedRange;
}
macro_rules! ranged_int {
($ty:tt -> $op:tt -> $variant:tt) => {
impl ToExpectedRange for $ty {
fn to_expected_range() -> ExpectedRange {
ExpectedRange::$variant
}
}
impl CoerceInto<$ty> for Tagged<BigInt> {
fn coerce_into(self, operation: impl Into<String>) -> Result<$ty, ShellError> {
match self.$op() {
Some(v) => Ok(v),
None => Err(ShellError::range_error(
$ty::to_expected_range(),
&self,
operation.into(),
)),
}
}
}
impl CoerceInto<$ty> for Tagged<&BigInt> {
fn coerce_into(self, operation: impl Into<String>) -> Result<$ty, ShellError> {
match self.$op() {
Some(v) => Ok(v),
None => Err(ShellError::range_error(
$ty::to_expected_range(),
&self,
operation.into(),
)),
}
}
}
};
}
ranged_int!(u8 -> to_u8 -> U8);
ranged_int!(u16 -> to_u16 -> U16);
ranged_int!(u32 -> to_u32 -> U32);
ranged_int!(u64 -> to_u64 -> U64);
ranged_int!(i8 -> to_i8 -> I8);
ranged_int!(i16 -> to_i16 -> I16);
ranged_int!(i32 -> to_i32 -> I32);
ranged_int!(i64 -> to_i64 -> I64);
macro_rules! ranged_decimal {
($ty:tt -> $op:tt -> $variant:tt) => {
impl ToExpectedRange for $ty {
fn to_expected_range() -> ExpectedRange {
ExpectedRange::$variant
}
}
impl CoerceInto<$ty> for Tagged<BigDecimal> {
fn coerce_into(self, operation: impl Into<String>) -> Result<$ty, ShellError> {
match self.$op() {
Some(v) => Ok(v),
None => Err(ShellError::range_error(
$ty::to_expected_range(),
&self,
operation.into(),
)),
}
}
}
impl CoerceInto<$ty> for Tagged<&BigDecimal> {
fn coerce_into(self, operation: impl Into<String>) -> Result<$ty, ShellError> {
match self.$op() {
Some(v) => Ok(v),
None => Err(ShellError::range_error(
$ty::to_expected_range(),
&self,
operation.into(),
)),
}
}
}
};
}
ranged_decimal!(f32 -> to_f32 -> F32);
ranged_decimal!(f64 -> to_f64 -> F64);
Reference in New Issue Copy Permalink