Cargo.toml

@@ -9,5 +9,4 @@ proc-macro = true
 [dependencies]
 quote = "1.0"
 syn = "2.0.90"
-naga = { version = "23.0.0", features = ["wgsl-in"] }
+naga = { version = "23.0.0", features = ["wgsl-in"] }
-regex = "1.11.1"

src/lib.rs

@@ -10,7 +10,8 @@ use {
 mod source_reader;
 
 struct ShaderModule {
-    source_file: source_reader::SourceMap,
+    source_file: source_reader::SourceFile,
+    naga_module: naga::Module,
 }
 
 impl ShaderModule {
@@ -20,7 +21,7 @@ impl ShaderModule {
     ) -> Result<Self, Error> {
         let source_file = source_reader::read_source_file(source_dir, source_filename)?;
 
-        let _naga_module = wgsl::parse_str(&source_file.full_text()).map_err(|err| {
+        let naga_module = wgsl::parse_str(&source_file.full_text()).map_err(|err| {
             if let Some(location) = err.location(&source_file.full_text()) {
                 let (inner_source_filename, inner_line_num) =
                     source_file.map_source_line_num(location.line_number as usize);
@@ -41,6 +42,7 @@ impl ShaderModule {
         })?;
         Ok(Self {
             source_file,
+            naga_module,
         })
     }
 

src/source_reader.rs

@@ -1,78 +1,55 @@
 use {
     crate::Error,
-    regex::Regex,
     std::{
         fs,
-        io::{BufRead, BufReader},
         path::{Path, PathBuf},
     },
 };
 
-pub struct SourceMap {
+struct SourceMap {
-    lines: Vec<String>,
+    filename: PathBuf,
-    files: Vec<PathBuf>,
+    offset: usize,
-    line_map: Vec<(usize, usize)>,
+    total_lines: usize,
+    insertions: Vec<SourceMap>,
 }
 
-impl SourceMap {
+pub struct SourceFile {
+    source_text: String,
+    source_map: SourceMap,
+}
+
+impl SourceFile {
     pub fn root_filename(&self) -> &Path {
-        &self.files[0]
+        &self.source_map.filename
     }
-    pub fn full_text(&self) -> String {
+    pub fn full_text(&self) -> &str {
-        self.lines.join("\n")
+        &self.source_text
     }
 
     pub fn map_source_line_num(&self, line_num: usize) -> (&Path, usize) {
-        let (source_file_index, source_file_line_num) = self.line_map[line_num];
+        (&self.source_map.filename, line_num)
-        (&self.files[source_file_index], source_file_line_num)
     }
 
-    pub fn all_filenames(&self) -> &Vec<PathBuf> {
+    pub fn all_filenames(&self) -> Vec<&Path> {
-        &self.files
+        vec![&self.source_map.filename]
     }
 }
 
-fn ingest_file(
+pub fn read_source_file(source_dir: &Path, filename: &Path) -> Result<SourceFile, Error> {
-    source_dir: &Path,
+    let source_text = fs::read_to_string(&source_dir.join(filename)).map_err(|err| {
-    filename: &Path,
-    source_map: &mut SourceMap,
-) -> Result<(), Error> {
-    let file = fs::File::open(source_dir.join(filename)).map_err(|err| {
         Error::from_message(format!(
             "Could not open \"{}\": {}",
             &filename.as_os_str().to_string_lossy(),
             err
         ))
     })?;
-    let file_num = source_map.files.len();
+    Ok(SourceFile {
-    source_map.files.push(filename.to_path_buf());
+        source_text,
-    let var_name = Regex::new(r"^//\#include\s+(.*)\s*$");
+        source_map: SourceMap {
-    let include_regex = var_name.unwrap();
+            filename: filename.into(),
-    for (line_num, line) in BufReader::new(file).lines().enumerate() {
+            offset: 0,
-        let line = line.map_err(|err| {
+            total_lines: 0,
-            Error::from_message(format!(
+            insertions: vec![],
-                "Error reading \"{}\": {}",
+        },
-                &filename.as_os_str().to_string_lossy(),
+    })
-                err
-            ))
-        })?;
-        if let Some(captures) = include_regex.captures(&line) {
-            let nested_filename = captures.get(1).unwrap().as_str();
-            ingest_file(source_dir, Path::new(nested_filename), source_map)?;
-        } else {
-            source_map.lines.push(line);
-            source_map.line_map.push((file_num, line_num));
-        }
-    }
-    Ok(())
-}
-
-pub fn read_source_file(source_dir: &Path, filename: &Path) -> Result<SourceMap, Error> {
-    let mut source_map = SourceMap {
-        lines: vec![],
-        files: vec![],
-        line_map: vec![],
-    };
-    ingest_file(source_dir, filename, &mut source_map)?;
-    Ok(source_map)
 }