Create a parse file context

Author: darrell-roberts

cli/src/parse.rs

@@ -7,7 +7,7 @@ use std::{
     path::PathBuf,
 };
 use typeshare_core::{
-    context::ParseContext,
+    context::{ParseContext, ParseFileContext},
     language::{CrateName, CrateTypes, SupportedLanguage, SINGLE_FILE_CRATE_NAME},
     parser::ParsedData,
     RenameExt,
@@ -102,15 +102,17 @@ pub fn parse_input(
                  file_name,
                  crate_name,
              }| {
-                let parsed_result = typeshare_core::parser::parse(
-                    &std::fs::read_to_string(&file_path)
+                let parse_file_context = ParseFileContext {
+                    source_code: std::fs::read_to_string(&file_path)
                         .with_context(|| format!("Failed to read input: {file_name}"))?,
-                    crate_name.clone(),
-                    file_name.clone(),
+                    crate_name: crate_name.clone(),
+                    file_name: file_name.clone(),
                     file_path,
-                    parse_context,
-                )
-                .with_context(|| format!("Failed to parse: {file_name}"))?;
+                };
+
+                let parsed_result =
+                    typeshare_core::parser::parse(parse_context, parse_file_context)
+                        .with_context(|| format!("Failed to parse: {file_name}"))?;
 
                 if let Some(parsed_data) = parsed_result {
                     parsed_crates

core/src/context.rs

@@ -14,8 +14,8 @@ pub struct ParseContext<'a> {
 }
 
 /// Parsing context for a single rust source file.
-pub struct ParseFileContext<'a> {
-    pub source_code: &'a str,
+pub struct ParseFileContext {
+    pub source_code: String,
     pub crate_name: CrateName,
     pub file_name: String,
     pub file_path: PathBuf,

core/src/parser.rs

@@ -1,5 +1,5 @@
 use crate::{
-    context::ParseContext,
+    context::{ParseContext, ParseFileContext},
     language::{CrateName, SupportedLanguage},
     rename::RenameExt,
     rust_types::{
@@ -16,7 +16,6 @@ use proc_macro2::Ident;
 use std::{
     collections::{BTreeSet, HashMap, HashSet},
     convert::TryFrom,
-    path::PathBuf,
 };
 use syn::{
     ext::IdentExt, parse::ParseBuffer, punctuated::Punctuated, visit::Visit, Attribute, Expr,
@@ -163,23 +162,27 @@ impl ParsedData {
 
 /// Parse the given Rust source string into `ParsedData`.
 pub fn parse(
-    source_code: &str,
-    crate_name: CrateName,
-    file_name: String,
-    file_path: PathBuf,
     parse_context: &ParseContext,
+    parse_file_context: ParseFileContext,
 ) -> Result<Option<ParsedData>, ParseError> {
     // We will only produce output for files that contain the `#[typeshare]`
     // attribute, so this is a quick and easy performance win
-    if !source_code.contains("#[typeshare") {
+    if !parse_file_context.source_code.contains("#[typeshare") {
         return Ok(None);
     }
 
+    let ParseFileContext {
+        source_code,
+        crate_name,
+        file_name,
+        file_path,
+    } = parse_file_context;
+
     debug!("parsing {file_name}");
     // Parse and process the input, ensuring we parse only items marked with
     // `#[typeshare]`
-    let mut import_visitor = TypeShareVisitor::new(crate_name, file_name, file_path, parse_context);
-    import_visitor.visit_file(&syn::parse_file(source_code)?);
+    let mut import_visitor = TypeShareVisitor::new(parse_context, crate_name, file_name, file_path);
+    import_visitor.visit_file(&syn::parse_file(&source_code)?);
 
     Ok(import_visitor.parsed_data())
 }

core/src/visitors.rs

@@ -57,10 +57,10 @@ pub struct TypeShareVisitor<'a> {
 impl<'a> TypeShareVisitor<'a> {
     /// Create an import visitor for a given crate name.
     pub fn new(
+        parse_context: &'a ParseContext<'a>,
         crate_name: CrateName,
         file_name: String,
         file_path: PathBuf,
-        parse_context: &'a ParseContext<'a>,
     ) -> Self {
         Self {
             parsed_data: ParsedData::new(crate_name, file_name, parse_context.multi_file),
@@ -615,10 +615,10 @@ mod test {
 
         let file: File = syn::parse_str(rust_code).unwrap();
         let mut visitor = TypeShareVisitor::new(
+            &parse_context,
             "my_crate".into(),
             "my_file".into(),
             "file_path".into(),
-            &parse_context,
         );
         visitor.visit_file(&file);
 

core/tests/agnostic_tests.rs

@@ -1,6 +1,6 @@
 use std::io::Write;
 use typeshare_core::{
-    context::ParseContext,
+    context::{ParseContext, ParseFileContext},
     language::{CrateTypes, Language, TypeScript},
     parser::{self, ParseError},
     rust_types::RustTypeParseError,
@@ -16,11 +16,13 @@ pub fn process_input(
     let parse_context = ParseContext::default();
 
     let mut parsed_data = parser::parse(
-        input,
-        "default_name".into(),
-        "file_name".into(),
-        "file_path".into(),
         &parse_context,
+        ParseFileContext {
+            source_code: input.to_string(),
+            crate_name: "default_name".into(),
+            file_name: "file_name".into(),
+            file_path: "file_path".into(),
+        },
     )?
     .unwrap();
 

core/tests/snapshot_tests.rs

@@ -10,7 +10,10 @@ use std::{
     path::{Path, PathBuf},
     sync::Once,
 };
-use typeshare_core::{context::ParseContext, language::Language};
+use typeshare_core::{
+    context::{ParseContext, ParseFileContext},
+    language::Language,
+};
 
 static TESTS_FOLDER_PATH: Lazy<PathBuf> =
     Lazy::new(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("data/tests"));
@@ -103,11 +106,13 @@ fn check(
     };
 
     let parsed_data = typeshare_core::parser::parse(
-        &rust_input,
-        "default_crate".into(),
-        "file_name".into(),
-        "file_path".into(),
         &parse_context,
+        ParseFileContext {
+            source_code: rust_input,
+            crate_name: "default_crate".into(),
+            file_name: "file_name".into(),
+            file_path: "file_path".into(),
+        },
     )?
     .unwrap();
     lang.generate_types(&mut typeshare_output, &HashMap::new(), parsed_data)?;