Introduce IrError as its own interpreter error

Author: udoprog

crates/rune-languageserver/src/state.rs

@@ -161,7 +161,6 @@ impl State {
                                 display_to_error,
                             );
                         }
-                        // TODO: match the source id with the document that has the error.
                         rune::LoadErrorKind::CompileError(error) => {
                             report(
                                 &sources,
@@ -172,6 +171,16 @@ impl State {
                                 display_to_error,
                             );
                         }
+                        rune::LoadErrorKind::QueryError(error) => {
+                            report(
+                                &sources,
+                                &mut by_url,
+                                error.span(),
+                                source_id,
+                                error,
+                                display_to_error,
+                            );
+                        }
                         rune::LoadErrorKind::LinkError(error) => match error {
                             rune::LinkerError::MissingFunction { hash, spans } => {
                                 for (span, _) in spans {

crates/rune-wasm/src/lib.rs

@@ -229,6 +229,21 @@ async fn inner_compile(input: String, budget: usize) -> CompileResult {
                                 message: error.to_string(),
                             });
                         }
+                        rune::LoadErrorKind::QueryError(error) => {
+                            let span = error.span();
+
+                            let start =
+                                Position::from(source.position_to_unicode_line_char(span.start));
+                            let end =
+                                Position::from(source.position_to_unicode_line_char(span.end));
+
+                            diagnostics.push(Diagnostic {
+                                kind: DiagnosticKind::Error,
+                                start,
+                                end,
+                                message: error.to_string(),
+                            });
+                        }
                         rune::LoadErrorKind::LinkError(error) => match error {
                             rune::LinkerError::MissingFunction { hash, spans } => {
                                 for (span, _) in spans {

crates/rune/src/compile_error.rs

@@ -1,16 +1,17 @@
 use crate::ast;
-use crate::ir_value::IrValue;
 use crate::unit_builder::UnitBuilderError;
-use crate::{ParseError, ParseErrorKind, Spanned};
-use runestick::{AccessError, CompileMeta, Item, SourceId, Span, TypeInfo, TypeOf};
+use crate::{
+    IrError, IrErrorKind, ParseError, ParseErrorKind, QueryError, QueryErrorKind, Spanned,
+};
+use runestick::{CompileMeta, Item, SourceId, Span};
 use std::error;
 use std::fmt;
 use std::io;
 use std::path::PathBuf;
 use thiserror::Error;
 
 /// A compile result.
-pub type CompileResult<T, E = CompileError> = std::result::Result<T, E>;
+pub type CompileResult<T> = std::result::Result<T, CompileError>;
 
 /// An error raised during compiling.
 #[derive(Debug)]
@@ -32,7 +33,7 @@ impl CompileError {
         }
     }
 
-    /// Get the kind of the cmopile error.
+    /// Get the kind of the compile error.
     pub fn kind(&self) -> &CompileErrorKind {
         &self.kind
     }
@@ -75,29 +76,6 @@ impl CompileError {
         CompileError::new(spanned, CompileErrorKind::ConstError { msg })
     }
 
-    /// An error raised when we expect a certain constant value but get another.
-    pub fn const_expected<S, E>(spanned: S, actual: &IrValue) -> Self
-    where
-        S: Spanned,
-        E: TypeOf,
-    {
-        CompileError::new(
-            spanned,
-            CompileErrorKind::ConstExpectedValue {
-                expected: E::type_info(),
-                actual: actual.type_info(),
-            },
-        )
-    }
-
-    /// Construct an access error.
-    pub fn access<S>(spanned: S, error: AccessError) -> Self
-    where
-        S: Spanned,
-    {
-        Self::new(spanned, CompileErrorKind::AccessError { error })
-    }
-
     /// Construct an experimental error.
     ///
     /// This should be used when an experimental feature is used which hasn't
@@ -149,37 +127,57 @@ impl From<UnitBuilderError> for CompileError {
     }
 }
 
+impl From<IrError> for CompileError {
+    fn from(error: IrError) -> Self {
+        CompileError {
+            span: error.span(),
+            kind: CompileErrorKind::IrError {
+                error: error.into_kind(),
+            },
+        }
+    }
+}
+
+impl From<QueryError> for CompileError {
+    fn from(error: QueryError) -> Self {
+        CompileError {
+            span: error.span(),
+            kind: CompileErrorKind::QueryError {
+                error: error.into_kind(),
+            },
+        }
+    }
+}
+
 /// Error when encoding AST.
 #[derive(Debug, Error)]
 pub enum CompileErrorKind {
-    /// An access error raised during compilation, usually happens during
-    /// constant evaluation.
-    #[error("access error: {error}")]
-    AccessError {
-        /// The source error.
-        #[source]
-        error: AccessError,
-    },
     /// An internal encoder invariant was broken.
     #[error("internal compiler error: {msg}")]
     Internal {
         /// The message of the internal error.
         msg: &'static str,
     },
+    /// Encountered an ir error.
+    #[error("ir error: {error}")]
+    IrError {
+        /// The source error.
+        #[source]
+        error: IrErrorKind,
+    },
+    /// Encountered a query error.
+    #[error("query error: {error}")]
+    QueryError {
+        /// The source error.
+        #[source]
+        error: QueryErrorKind,
+    },
     /// A constant evaluation errored.
     #[error("error during constant evaluation: {msg}")]
     ConstError {
         /// Message describing the error.
         msg: &'static str,
     },
-    /// A constant evaluation errored.
-    #[error("expected a value of type {expected} but got {actual}")]
-    ConstExpectedValue {
-        /// The expected value.
-        expected: TypeInfo,
-        /// The value we got instead.
-        actual: TypeInfo,
-    },
     /// Trying to use an experimental feature which was not enabled.
     #[error("experimental feature: {msg}")]
     Experimental {
@@ -400,9 +398,6 @@ pub enum CompileErrorKind {
     /// The pattern is not supported as a binding.
     #[error("not a valid binding")]
     UnsupportedBinding,
-    /// Error raised when trying to use a break outside of a loop.
-    #[error("break outside of supported loop")]
-    BreakOutsideOfLoop,
     /// Attempting to use a float in a match pattern.
     #[error("floating point numbers cannot be used in patterns")]
     MatchFloatInPattern,
@@ -442,10 +437,7 @@ pub enum CompileErrorKind {
         /// The number that was an unsupported tuple index.
         number: ast::Number,
     },
-    /// Trying to treat a non-constant expression as constant.
-    #[error("not a constant expression")]
-    NotConst,
-    /// Trying to process a cycle of constants.
-    #[error("constant cycle detected")]
-    ConstCycle,
+    /// Error raised when trying to use a break outside of a loop.
+    #[error("break outside of loop")]
+    BreakOutsideOfLoop,
 }

crates/rune/src/compiler.rs

@@ -137,7 +137,9 @@ pub fn compile_with_options(
             Ok(true) => (),
             Ok(false) => break,
             Err((source_id, error)) => {
-                worker.errors.push(LoadError::new(source_id, error));
+                worker
+                    .errors
+                    .push(LoadError::new(source_id, CompileError::from(error)));
             }
         }
     }

crates/rune/src/diagnostics.rs

@@ -335,6 +335,7 @@ impl EmitDiagnostics for LoadError {
 
                 error.span()
             }
+            LoadErrorKind::QueryError(error) => error.span(),
         };
 
         if let Some(e) = self.kind().source() {

crates/rune/src/eval/ir.rs

@@ -12,6 +12,7 @@ impl Eval<&Ir> for IrInterpreter<'_> {
             IrKind::Binary(ir_binary) => self.eval(ir_binary, used),
             IrKind::Decl(ir_decl) => self.eval(ir_decl, used),
             IrKind::Set(ir_set) => self.eval(ir_set, used),
+            IrKind::Assign(ir_assign) => self.eval(ir_assign, used),
             IrKind::Template(ir_template) => self.eval(ir_template, used),
             IrKind::Name(name) => Ok(self.resolve_var(name.as_ref(), ir.span(), used)?),
             IrKind::Target(ir_target) => Ok(self.scopes.get_target(ir_target)?),

crates/rune/src/eval/ir_assign.rs

@@ -0,0 +1,16 @@
+use crate::eval::prelude::*;
+
+impl Eval<&IrAssign> for IrInterpreter<'_> {
+    type Output = IrValue;
+
+    fn eval(&mut self, ir_assign: &IrAssign, used: Used) -> Result<Self::Output, EvalOutcome> {
+        self.budget.take(ir_assign)?;
+        let value = self.eval(&*ir_assign.value, used)?;
+
+        self.scopes.mut_target(&ir_assign.target, move |t| {
+            ir_assign.op.assign(ir_assign, t, value)
+        })?;
+
+        Ok(IrValue::Unit)
+    }
+}

crates/rune/src/eval/ir_binary.rs

@@ -50,29 +50,23 @@ impl Eval<&IrBinary> for IrInterpreter<'_> {
                 }
                 IrBinaryOp::Shl => {
                     let b = u32::try_from(b).map_err(|_| {
-                        CompileError::const_error(
-                            &ir_binary.rhs,
-                            "cannot be converted to shift operand",
-                        )
+                        IrError::custom(&ir_binary.rhs, "cannot be converted to shift operand")
                     })?;
 
                     let n = a
                         .checked_shl(b)
-                        .ok_or_else(|| CompileError::const_error(span, "integer shift overflow"))?;
+                        .ok_or_else(|| IrError::custom(span, "integer shift overflow"))?;
 
                     return Ok(IrValue::Integer(n));
                 }
                 IrBinaryOp::Shr => {
                     let b = u32::try_from(b).map_err(|_| {
-                        CompileError::const_error(
-                            &ir_binary.rhs,
-                            "cannot be converted to shift operand",
-                        )
+                        IrError::custom(&ir_binary.rhs, "cannot be converted to shift operand")
                     })?;
 
-                    let n = a.checked_shr(b).ok_or_else(|| {
-                        CompileError::const_error(span, "integer shift underflow")
-                    })?;
+                    let n = a
+                        .checked_shr(b)
+                        .ok_or_else(|| IrError::custom(span, "integer shift underflow"))?;
 
                     return Ok(IrValue::Integer(n));
                 }
@@ -109,7 +103,7 @@ fn checked_int(
     op: impl FnOnce(i64, i64) -> Option<i64>,
     msg: &'static str,
     span: Span,
-) -> Result<IrValue, CompileError> {
-    let n = op(a, b).ok_or_else(|| CompileError::const_error(span, msg))?;
+) -> Result<IrValue, IrError> {
+    let n = op(a, b).ok_or_else(|| IrError::custom(span, msg))?;
     Ok(IrValue::Integer(n))
 }

crates/rune/src/eval/ir_loop.rs

@@ -35,7 +35,7 @@ impl Eval<&IrLoop> for IrInterpreter<'_> {
                                 return Ok(value);
                             }
 
-                            return Err(EvalOutcome::from(CompileError::const_error(
+                            return Err(EvalOutcome::from(IrError::custom(
                                 span,
                                 "break with value is not supported for unconditional loops",
                             )));

crates/rune/src/eval/ir_template.rs

@@ -30,9 +30,7 @@ impl Eval<&IrTemplate> for IrInterpreter<'_> {
                             write!(buf, "{}", b).unwrap();
                         }
                         IrValue::String(s) => {
-                            let s = s
-                                .borrow_ref()
-                                .map_err(|e| CompileError::access(ir_template, e))?;
+                            let s = s.borrow_ref().map_err(IrError::access(ir_template))?;
                             buf.push_str(&*s);
                         }
                         _ => {

crates/rune/src/eval/mod.rs

@@ -1,10 +1,11 @@
 use crate::ir::IrPat;
 use crate::ir_interpreter::IrInterpreter;
 use crate::ir_value::IrValue;
-use crate::{CompileError, ParseError, Spanned};
+use crate::{IrError, QueryError, Spanned};
 use runestick::Span;
 
 mod ir;
+mod ir_assign;
 mod ir_binary;
 mod ir_branches;
 mod ir_break;
@@ -71,7 +72,7 @@ where
         let value = compiler
             .eval(self, used)?
             .into_bool()
-            .map_err(|actual| CompileError::const_expected::<_, bool>(span, &actual))?;
+            .map_err(|actual| IrError::expected::<_, bool>(span, &actual))?;
 
         Ok(value)
     }
@@ -82,7 +83,7 @@ impl Matches for IrPat {
         &self,
         compiler: &mut IrInterpreter<'_>,
         value: IrValue,
-        used: Used,
+        _used: Used,
         spanned: S,
     ) -> Result<bool, EvalOutcome>
     where
@@ -102,7 +103,7 @@ pub(crate) enum EvalOutcome {
     /// Encountered ast that is not a constant expression.
     NotConst(Span),
     /// A compile error.
-    Error(CompileError),
+    Error(IrError),
     /// Break until the next loop, or the optional label.
     Break(Span, EvalBreak),
 }
@@ -117,14 +118,14 @@ impl EvalOutcome {
     }
 }
 
-impl From<CompileError> for EvalOutcome {
-    fn from(error: CompileError) -> Self {
+impl From<IrError> for EvalOutcome {
+    fn from(error: IrError) -> Self {
         Self::Error(error)
     }
 }
 
-impl From<ParseError> for EvalOutcome {
-    fn from(error: ParseError) -> Self {
+impl From<QueryError> for EvalOutcome {
+    fn from(error: QueryError) -> Self {
         Self::Error(error.into())
     }
 }

crates/rune/src/eval/prelude.rs

@@ -4,7 +4,6 @@ pub(crate) use crate::eval::{ConstAs, Eval, EvalBreak, EvalOutcome, Matches, Use
 pub(crate) use crate::ir::*;
 pub(crate) use crate::ir_interpreter::IrInterpreter;
 pub(crate) use crate::ir_value::IrValue;
-pub(crate) use crate::CompileError;
-pub(crate) use crate::Spanned;
+pub(crate) use crate::{IrError, Spanned};
 pub(crate) use runestick::{Shared, Span};
 pub(crate) use std::convert::TryFrom;