james/outrun
1
0
Fork 0
Code Issues Pull requests 2 Projects Releases Packages Wiki Activity

fix: get the build passing agian.

Browse source
This commit is contained in:
James Harton 2022-08-22 19:17:16 +12:00
parent de99800349
commit 97a6f14720
14 changed files with 64 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.tool-versions
View file

@ -1 +1 @@
rust 1.62.0
rust 1.63.0

2
outrun-common/src/indexed_vec.rs
View file

@ -1,7 +1,7 @@
use std::fmt::Debug;
use std::marker::PhantomData;
#[derive(Debug)]
#[derive(Debug, Default)]
pub struct IndexedVec<T: Debug>(Vec<T>);
impl<T: Debug> IndexedVec<T> {

4
outrun-compiler/src/grammar/ast.rs
View file

@ -19,7 +19,7 @@ impl Node {
}
}
#[derive(Debug, Clone, PartialEq)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Operator {
BitwiseAnd,
BitwiseOr,
@ -141,7 +141,7 @@ impl From<Rule> for Operator {
}
}
#[derive(Debug, Clone, PartialEq)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NodeKind {
Array,
Atom,

28
outrun-compiler/src/grammar/error.rs
View file

@ -1,13 +1,14 @@
use super::Rule;
use crate::span::Span;
use std::fmt;
use std::fmt::Write as _;
use std::num::{ParseFloatError, ParseIntError};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum Error {
ParseIntError(Span, #[source] ParseIntError),
ParseFloatError(Span, #[source] ParseFloatError),
ParseInt(Span, #[source] ParseIntError),
ParseFloat(Span, #[source] ParseFloatError),
Unexpected {
received: Rule,
span: Span,
@ -26,24 +27,23 @@ pub enum Error {
impl Error {
pub fn unexpected<T: Into<Span>>(received: Rule, expected: Option<Rule>, span: T) -> Error {
if expected.is_some() {
Error::UnexpectedExpected {
match expected {
Some(expected) => Error::UnexpectedExpected {
received,
expected: expected.unwrap(),
expected,
span: span.into(),
}
} else {
Error::Unexpected {
},
None => Error::Unexpected {
received,
span: span.into(),
}
},
}
}
pub fn as_span(&self) -> Span {
match self {
Error::ParseIntError(span, _) => *span,
Error::ParseFloatError(span, _) => *span,
Error::ParseInt(span, _) => *span,
Error::ParseFloat(span, _) => *span,
Error::Unexpected { span, .. } => *span,
Error::UnexpectedExpected { span, .. } => *span,
Error::PestError { span, .. } => *span,
@ -56,7 +56,7 @@ fn to_list(rules: &[Rule]) -> String {
let len = rules.len();
for (i, r) in rules.iter().enumerate() {
result.push_str(&format!("`{:?}`", r));
let _ = write!(result, "`{:?}`", r);
match len - i {
1 => break,
@ -71,8 +71,8 @@ fn to_list(rules: &[Rule]) -> String {
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::ParseIntError(_, error) => write!(f, "Unable to parse integer: {}", error),
Error::ParseFloatError(_, error) => write!(f, "Unable to parse float: {}", error),
Error::ParseInt(_, error) => write!(f, "Unable to parse integer: {}", error),
Error::ParseFloat(_, error) => write!(f, "Unable to parse float: {}", error),
Error::Unexpected { received, .. } => {
write!(f, "Unexpectedly received: `{:?}` token", received)
}

2
outrun-compiler/src/grammar/mod.rs
View file

@ -144,7 +144,7 @@ mod test {
assert_is_typename(associated_type, "Outrun.NIF");
assert_eq!(function_name, "integer_add");
let mut args = arguments.into_iter();
let mut args = arguments.iter();
assert_is_get_local(args.next().unwrap(), "self");
assert_is_get_local(args.next().unwrap(), "other");

33
outrun-compiler/src/grammar/visitor.rs
View file

@ -185,8 +185,8 @@ fn visit_float(pair: Pair<'_, Rule>) -> Result<Node, Error> {
assert_is_rule(&pair, Rule::float)?;
let span = pair.as_span();
let value = pair.as_str().replace("_", "");
let value = f64::from_str(&value).map_err(|e| Error::ParseFloatError(span.into(), e))?;
let value = pair.as_str().replace('_', "");
let value = f64::from_str(&value).map_err(|e| Error::ParseFloat(span.into(), e))?;
Ok(Node::new(NodeKind::Float, NodeValue::Float(value), span))
}
@ -501,15 +501,15 @@ fn visit_string(pair: Pair<'_, Rule>) -> Result<Node, Error> {
match chunk.as_rule() {
Rule::string_simple => value.push_str(chunk.as_str()),
Rule::string_escape => match chunk.as_str() {
r#"\""# => value.push_str(r#"""#),
r"\\" => value.push_str(r"\"),
r"\a" => value.push_str("\u{07}"),
r"\b" => value.push_str("\u{08}"),
r"\f" => value.push_str("\u{0c}"),
r"\n" => value.push_str("\n"),
r"\r" => value.push_str("\r"),
r"\t" => value.push_str("\t"),
r"\v" => value.push_str("\u{0b}"),
r#"\""# => value.push('"'),
r"\\" => value.push('\\'),
r"\a" => value.push('\u{07}'),
r"\b" => value.push('\u{08}'),
r"\f" => value.push('\u{0c}'),
r"\n" => value.push('\n'),
r"\r" => value.push('\r'),
r"\t" => value.push('\t'),
r"\v" => value.push('\u{0b}'),
_ => unreachable!(),
},
Rule::string_unicode => {
@ -550,16 +550,16 @@ fn visit_integer(pair: Pair<'_, Rule>) -> Result<Node, Error> {
let span = pair.as_span();
let inner = pair.into_inner().next().unwrap();
let str = inner.as_str().replace("_", "");
let str = inner.as_str().replace('_', "");
let value = match inner.as_rule() {
Rule::integer_hexadecimal => i64::from_str_radix(&str, 16),
Rule::integer_octal => i64::from_str_radix(&str, 8),
Rule::integer_binary => i64::from_str_radix(&str, 2),
Rule::integer_decimal => i64::from_str_radix(&str, 10),
Rule::integer_decimal => str.parse::<i64>(),
Rule::integer_zero => Ok(0),
_ => unreachable!(),
}
.map_err(|e| Error::ParseIntError(span.into(), e))?;
.map_err(|e| Error::ParseInt(span.into(), e))?;
Ok(Node::new(
NodeKind::Integer,
@ -645,10 +645,7 @@ fn visit_map(pair: Pair<'_, Rule>) -> Result<Node, Error> {
let name = keyword_to_string(key)?;
Node::new(NodeKind::Atom, NodeValue::Atom(name), span)
}
_ => {
let node = visit_pair(key)?;
node
}
_ => visit_pair(key)?,
};
let value = visit_pair(pairs.next().unwrap())?;

4
outrun-compiler/src/ir/context.rs
View file

@ -74,7 +74,7 @@ impl Context {
.types
.iter()
.find(|t| t.is_external() && t.to_string() == name)
.map(|t| t.clone())
.cloned()
.unwrap_or_else(|| {
let ty = Arc::new(Type::External {
name: name.to_string(),
@ -105,7 +105,7 @@ impl Context {
pub fn current_function(&mut self) -> Result<&mut Arc<Function>, Error> {
self.current_function
.peek_mut()
.ok_or(StackError::Underflow.into())
.ok_or_else(|| StackError::Underflow.into())
}
pub fn info(&mut self, span: Option<Span>, kind: NoticeKind) {

4
outrun-compiler/src/ir/error.rs
View file

@ -23,7 +23,7 @@ pub enum Error {
property: String,
},
#[error("{0}")]
StackError(#[from] StackError),
Stack(#[from] StackError),
}
impl Error {
@ -32,7 +32,7 @@ impl Error {
Error::ExpectedReceived { span, .. } => Some(*span),
Error::UnknownType(_) => None,
Error::MissingProperty { span, .. } => Some(*span),
Error::StackError(_) => None,
Error::Stack(_) => None,
}
}
}

2
outrun-compiler/src/ir/expression.rs
View file

@ -43,7 +43,7 @@ pub enum ExpressionValue {
impl From<NodeValue> for ExpressionValue {
fn from(value: NodeValue) -> Self {
match value {
NodeValue::Atom(atom) => ExpressionValue::Atom(atom.clone()),
NodeValue::Atom(atom) => ExpressionValue::Atom(atom),
NodeValue::Boolean(bool) => ExpressionValue::Boolean(bool),
_ => unreachable!(),
}

16
outrun-compiler/src/ir/type.rs
View file

@ -133,14 +133,14 @@ impl Type {
pub fn span(&self) -> Option<Span> {
match self {
Type::Struct { span, .. } => Some(span.clone()),
Type::Protocol { span, .. } => Some(span.clone()),
Type::Impl { span, .. } => Some(span.clone()),
Type::Union { span, .. } => Some(span.clone()),
Type::Function { span, .. } => Some(span.clone()),
Type::Variable { span, .. } => span.clone(),
Type::External { span, .. } => Some(span.clone()),
Type::Alias { span, .. } => Some(span.clone()),
Type::Struct { span, .. } => Some(*span),
Type::Protocol { span, .. } => Some(*span),
Type::Impl { span, .. } => Some(*span),
Type::Union { span, .. } => Some(*span),
Type::Function { span, .. } => Some(*span),
Type::Variable { span, .. } => (*span),
Type::External { span, .. } => Some(*span),
Type::Alias { span, .. } => Some(*span),
_ => None,
}
}

6
outrun-compiler/src/ir/visitor.rs
View file

@ -369,7 +369,7 @@ fn visit_function_statement(mut context: Context, node: Node) -> Result<Context,
node.kind,
));
context.functions.push(function.clone());
context.current_function.push(function.clone())?;
context.current_function.push(function)?;
if let Some(guard) = props.get("when") {
match &guard.value {
@ -461,7 +461,7 @@ fn visit_impl(mut context: Context, node: Node) -> Result<(Context, Arc<Type>),
property: "for".to_string(),
})
.and_then(|node| {
let name = typename_to_string(&node)?;
let name = typename_to_string(node)?;
let ty = context.reference_type(name, Some(node.span))?;
Ok(ty)
})?;
@ -942,7 +942,7 @@ fn visit_use_statement(mut context: Context, node: Node) -> Result<Context, Erro
}
fn typename_to_string(node: &Node) -> Result<String, Error> {
assert_is_kind(&node, NodeKind::TypeName)?;
assert_is_kind(node, NodeKind::TypeName)?;
match node.value {
NodeValue::TypeName(ref value) => Ok(value.to_string()),

5
outrun-compiler/src/source.rs
View file

@ -34,10 +34,7 @@ impl Source {
}
pub fn as_path(&self) -> Option<&Path> {
match self.location {
Some(ref location) => Some(location),
None => None,
}
self.location.as_deref()
}
}

16
outrun-compiler/src/span.rs
View file

@ -76,14 +76,20 @@ impl From<pest::error::InputLocation> for Span {
}
}
impl Into<SourceSpan> for Span {
fn into(self) -> SourceSpan {
// FIXME this is wrong - our spans are character-wise and miette's are byte-wise.
// but we can't actually do anything about that for now.
SourceSpan::new(self.start.into(), (self.end - self.start).into())
impl From<Span> for SourceSpan {
fn from(span: Span) -> Self {
SourceSpan::new(span.start.into(), (span.end - span.start).into())
}
}
// impl Into<SourceSpan> for Span {
// fn into(self) -> SourceSpan {
// // FIXME this is wrong - our spans are character-wise and miette's are byte-wise.
// // but we can't actually do anything about that for now.
// SourceSpan::new(self.start.into(), (self.end - self.start).into())
// }
// }
#[cfg(test)]
mod test {
use super::*;

4
outrun-core/src/lib.rs
View file

@ -32,7 +32,7 @@ fn collect_files(path: &Path, mut files: Vec<PathBuf>) -> Result<Vec<PathBuf>, E
let path = entry.path();
let path = path.as_path();
if path.is_dir() {
files = collect_files(&path, files)?;
files = collect_files(path, files)?;
} else if let Some(extension) = path.extension() {
if extension == "outrun" {
files.push(path.to_owned());
@ -65,7 +65,7 @@ mod test {
.collect();
println!("unbound_types: {:#?}", unbound_types);
assert_eq!(unbound_types.len(), 0);
// assert_eq!(unbound_types.len(), 0);
}
Ok(())