refactor(opy-rs): simplify redundant compiler paths

crates/opy-cli/src/main.rs

@@ -14,15 +14,13 @@ use std::process::ExitCode;
 
 use clap::{CommandFactory, Parser, error::ErrorKind};
 use clap_complete::{generate, shells};
-use opy_rs::tooling::{CheckOutcome, Diagnostic as OpyDiagnostic, check};
+use opy_rs::tooling::{CheckOutcome, Diagnostic as OpyDiagnostic, SourceLocation, check};
 use opy_rs::{CompileDiagnostic, CompileStatus, Compiler};
 use opy_rs::{FilesystemProject, LANGUAGE_NAME, LANGUAGE_VERSION};
 use serde::Serialize;
 
 use crate::cli::{CheckArgs, Cli, Command, CompileArgs, FileArgs, OutputFormatArg};
-use crate::present::{
-    CheckView, DiagnosticSeverity, DiagnosticView, PositionView, Presentation, SpanView,
-};
+use crate::present::{CheckView, DiagnosticView, PositionView, Presentation, SpanView};
 
 fn main() -> ExitCode {
     let cli = match Cli::try_parse() {
@@ -234,45 +232,33 @@ fn check_view(outcome: &CheckOutcome) -> CheckView {
 
 fn diagnostic_view(diagnostic: &OpyDiagnostic) -> DiagnosticView {
     DiagnosticView {
-        severity: match diagnostic.severity {
-            opy_rs::tooling::DiagnosticSeverity::Error => DiagnosticSeverity::Error,
-            opy_rs::tooling::DiagnosticSeverity::Warning => DiagnosticSeverity::Warning,
-        },
+        severity: diagnostic.severity.into(),
         code: diagnostic.code.clone(),
         message: diagnostic.message.clone(),
-        span: diagnostic.span.as_ref().map(|span| SpanView {
-            path: span.path.clone(),
-            start: PositionView {
-                line: span.start.line,
-                col: span.start.col,
-            },
-            end: PositionView {
-                line: span.end.line,
-                col: span.end.col,
-            },
-        }),
+        span: diagnostic.span.as_ref().map(diagnostic_span_view),
     }
 }
 
 fn compile_diagnostic_view(diagnostic: &CompileDiagnostic) -> DiagnosticView {
     DiagnosticView {
-        severity: match diagnostic.severity {
-            opy_rs::tooling::DiagnosticSeverity::Error => DiagnosticSeverity::Error,
-            opy_rs::tooling::DiagnosticSeverity::Warning => DiagnosticSeverity::Warning,
-        },
+        severity: diagnostic.severity.into(),
         code: diagnostic.code.clone(),
         message: diagnostic.message.clone(),
-        span: diagnostic.span.as_ref().map(|span| SpanView {
-            path: span.path.clone(),
-            start: PositionView {
-                line: span.start.line,
-                col: span.start.col,
-            },
-            end: PositionView {
-                line: span.end.line,
-                col: span.end.col,
-            },
-        }),
+        span: diagnostic.span.as_ref().map(diagnostic_span_view),
+    }
+}
+
+fn diagnostic_span_view(span: &SourceLocation) -> SpanView {
+    SpanView {
+        path: span.path.clone(),
+        start: PositionView {
+            line: span.start.line,
+            col: span.start.col,
+        },
+        end: PositionView {
+            line: span.end.line,
+            col: span.end.col,
+        },
     }
 }
 

crates/opy-cli/src/present.rs

@@ -1,5 +1,7 @@
 use std::io::{IsTerminal, Write};
 
+use opy_rs::tooling::DiagnosticSeverity as OpyDiagnosticSeverity;
+
 use crate::cli::{ColorArg, RendererArg};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -8,6 +10,15 @@ pub(crate) enum DiagnosticSeverity {
     Warning,
 }
 
+impl From<OpyDiagnosticSeverity> for DiagnosticSeverity {
+    fn from(value: OpyDiagnosticSeverity) -> Self {
+        match value {
+            OpyDiagnosticSeverity::Error => Self::Error,
+            OpyDiagnosticSeverity::Warning => Self::Warning,
+        }
+    }
+}
+
 impl DiagnosticSeverity {
     fn as_str(self) -> &'static str {
         match self {

crates/opy-provider/src/main.rs

@@ -1070,17 +1070,7 @@ fn document_lsp_position(
         .map(|document| document.text.clone())
         .or_else(|| std::fs::read_to_string(&resolved).ok())
         .unwrap_or_default();
-    let character = source
-        .lines()
-        .nth(line.saturating_sub(1) as usize)
-        .map(|text| {
-            text.chars()
-                .take(col.saturating_sub(1) as usize)
-                .map(char::len_utf16)
-                .sum::<usize>() as u32
-        })
-        .unwrap_or_else(|| col.saturating_sub(1));
-    json!({ "line": line.saturating_sub(1), "character": character })
+    lsp_position(&source, line, col)
 }
 
 fn check_result(project: &LoadedProject, outcome: &CheckOutcome) -> Value {
@@ -1209,17 +1199,21 @@ fn diagnostic_range(project: &LoadedProject, location: Option<&SourceLocation>)
         });
     };
     json!({
-        "start": lsp_position(project, &location.path, location.start.line, location.start.col),
-        "end": lsp_position(project, &location.path, location.end.line, location.end.col),
+        "start": project_lsp_position(project, &location.path, location.start.line, location.start.col),
+        "end": project_lsp_position(project, &location.path, location.end.line, location.end.col),
     })
 }
 
-fn lsp_position(project: &LoadedProject, path: &str, line: u32, col: u32) -> Value {
+fn project_lsp_position(project: &LoadedProject, path: &str, line: u32, col: u32) -> Value {
     let source = if path == path_string(project.filesystem.main_path()) {
         project.filesystem.source().to_owned()
     } else {
         std::fs::read_to_string(resolved_project_path(project, path)).unwrap_or_default()
     };
+    lsp_position(&source, line, col)
+}
+
+fn lsp_position(source: &str, line: u32, col: u32) -> Value {
     let character = source
         .lines()
         .nth(line.saturating_sub(1) as usize)

crates/opy-rs/src/compile_time.rs

@@ -64,7 +64,7 @@ pub(crate) fn evaluate(
                 .map(|arg| evaluate(arg, constants, bindings, stack))
                 .collect::<Option<Vec<_>>>()?;
             let mut result = text.clone();
-            for (index, value) in values.iter().enumerate() {
+            for (index, value) in values.into_iter().enumerate() {
                 result = result.replace(&format!("{{{index}}}"), &display(value)?);
             }
             Some(Value::String(result))
@@ -197,10 +197,10 @@ fn evaluate_index(collection: Value, index: Value) -> Option<Value> {
     }
 }
 
-fn display(value: &Value) -> Option<String> {
+pub(crate) fn display(value: Value) -> Option<String> {
     match value {
-        Value::Number(value) if value.is_finite() => Some(workshop_number_text(*value)),
-        Value::String(value) => Some(value.clone()),
+        Value::Number(value) if value.is_finite() => Some(workshop_number_text(value)),
+        Value::String(value) => Some(value),
         Value::Bool(value) => Some(value.to_string()),
         _ => None,
     }
@@ -219,7 +219,7 @@ pub(crate) fn round_half_up(value: f64) -> f64 {
     }
 }
 
-pub(crate) fn workshop_number_text(value: f64) -> String {
+fn workshop_number_text(value: f64) -> String {
     let rounded = (value * 100.0).round() / 100.0;
     if rounded.fract() == 0.0 {
         format!("{}", rounded as i64)

crates/opy-rs/src/compiler/action_optimization.rs

@@ -7,6 +7,7 @@ use workshop_rs::{Action, Value};
 use super::Compiler;
 use super::operator_optimization::falsy;
 use super::size_optimization::{action_values, is_empty_string};
+use super::value_walk::for_each_child;
 
 pub(super) struct ActionOptimizer<'a> {
     compiler: &'a Compiler,
@@ -88,10 +89,7 @@ impl<'a> ActionOptimizer<'a> {
     fn nested(&self, value: &mut Value) {
         match value {
             Value::Call { name, args } => self.booleans(Kind::Value, name, args),
-            Value::Array(elements) => elements.iter_mut().for_each(|element| self.nested(element)),
-            Value::Vector { x, y, z } => [x, y, z].into_iter().for_each(|part| self.nested(part)),
-            Value::PlayerVariable { player, .. } => self.nested(player),
-            _ => {}
+            _ => for_each_child(value, |child| self.nested(child)),
         }
     }
 }