renamed legacy moudles to *_legacy

src/cli.rs

@@ -12,10 +12,10 @@ use notify::EventKind::Modify;
 use notify::{Event, RecursiveMode, Watcher};
 use pest::Parser as PestParser;
 
-use crate::resolver::resolve_cst;
-use crate::{cst_legacy, render};
+use crate::resolver_legacy::resolve_cst;
+use crate::{cst_legacy, render_legacy};
 use crate::compiler::ast::{AstParser, AstParserError};
-use crate::render::RenderError;
+use crate::render_legacy::RenderError;
 
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
@@ -150,7 +150,7 @@ pub(crate) fn run_build(source: String, output: Option<String>) -> Result<(), Cl
     File::create(output_file_path)
         .map_err(|err| CliError::CantCrateOutputFile(err))?
         .write_all(
-            &render::render_cst(resolved_cst)
+            &render_legacy::render_cst(resolved_cst)
                 .map_err(CliError::Rendering)?,
         )
         .map_err(|err| CliError::CantCrateOutputFile(err))

src/compiler/cst/parser.rs

@@ -3,7 +3,8 @@ use std::path::PathBuf;
 use crate::compiler::ast::{AstNode, AstNodeType};
 use crate::compiler::cst::{CstActualParameter, CstAtom, CstConstantStatement, CstEmitStatement, CstFunctionStatement};
 use crate::compiler::cst::node::CstFile;
-use crate::encoding;
+use crate::compiler::util::encoding::decode_bytes_from_string;
+use crate::encoding_legacy;
 
 #[derive(Debug)]
 pub(crate) enum CstParserError {
@@ -253,7 +254,7 @@ fn parse_atom_hex_into(node: &AstNode, buf: &mut Vec<CstAtom>) -> Result<(), Cst
     let content = node.clone().content
         .ok_or(CstParserError::MissingContent { node_type: AstNodeType::AtomHex })?;
 
-    let bytes = encoding::decode_byte_ref(&content)
+    let bytes = decode_bytes_from_string(&content)
         .map_err(|x| CstParserError::MalformedNodeValue {
             message: format!("can't parse bytes {}", content)
         })?;

src/compiler/util/encoding.rs

@@ -0,0 +1,11 @@
+pub(crate) fn decode_bytes_from_string(s: &String) -> Result<Vec<u8>, ()> {
+    (0..s.len())
+        .step_by(2)
+        .map(|i| {
+            if s.len() < 2 {
+                return Err(());
+            }
+            u8::from_str_radix(&s[i..i + 2], 16).map_err(|_| ())
+        })
+        .collect()
+}

src/compiler/util/mod.rs

@@ -1,3 +1,4 @@
 mod byte_buffer;
+pub(crate) mod encoding;
 
 pub(crate) use byte_buffer::ByteBuffer;

src/cst_legacy.rs

@@ -1,7 +1,7 @@
 use crate::compiler::ast::{AstNode, AstNodeType};
 use crate::cst_legacy::CstParseError::NodeValueMissing;
-use crate::encoding;
-use crate::encoding::to_shrunk_bytes;
+use crate::encoding_legacy;
+use crate::encoding_legacy::to_shrunk_bytes;
 
 #[derive(Debug, Clone)]
 pub(crate) struct CstAtomStrip(Vec<CstAtom>);
@@ -257,7 +257,7 @@ fn parse_cst_atom(node: AstNode) -> CstAtom {
         }
         AstNodeType::AtomHex => {
             return CstAtom::Resolved {
-                value: encoding::decode_byte(node_value.unwrap()).unwrap(),
+                value: encoding_legacy::decode_byte(node_value.unwrap()).unwrap(),
             };
         }
         AstNodeType::AtomConst => {

src/encoding.rs → src/encoding_legacy.rs

@@ -11,19 +11,6 @@ pub(crate) fn decode_byte(s: String) -> Result<Vec<u8>, ()> {
         .collect()
 }
 
-pub(crate) fn decode_byte_ref(s: &String) -> Result<Vec<u8>, ()> {
-    (0..s.len())
-        .step_by(2)
-        .map(|i| {
-            if s.len() < 2 {
-                return Err(());
-            }
-            u8::from_str_radix(&s[i..i + 2], 16).map_err(|_| ())
-        })
-        .collect()
-}
-
-
 pub(crate) fn to_shrunk_bytes(value: u32) -> Vec<u8> {
     let mut bytes = Vec::new();
     let mut value = value;
@@ -36,7 +23,7 @@ pub(crate) fn to_shrunk_bytes(value: u32) -> Vec<u8> {
 
 #[cfg(test)]
 mod tests {
-    use crate::encoding::decode_byte;
+    use crate::encoding_legacy::decode_byte;
 
     #[test]
     fn given_valid_bytes_then_decode() {

src/main.rs

@@ -9,9 +9,9 @@ use crate::compiler::{FileCompilerSource, HexoCompiler, HexoCompilerContext, Str
 
 mod cli;
 mod cst_legacy;
-mod encoding;
-mod render;
-mod resolver;
+mod encoding_legacy;
+mod render_legacy;
+mod resolver_legacy;
 mod compiler;
 
 fn main() {