Removing debug prints

ecosystem/python/parser/src/module/mod.rs

@@ -37,7 +37,6 @@ pub(crate) struct SubPath<'a>(pub &'a std::path::Path);
 impl Parser<File<'_>> for PythonParser {
     type Output = Module;
     fn parse(&self, File(input): File<'_>, config: &ParserConfig) -> Result<Self::Output> {
-        println!("Parsing file: {}", input.display());
         let content = std::fs::read_to_string(input)?;
         let module = ModuleParser.parse(content.as_str(), config)?;
         let mut module = self.parse(module, config)?;

ecosystem/python/parser/src/parser/mod.rs

@@ -37,7 +37,6 @@ impl PythonParser {
         // This line replaces "-" with "_" in the file name
         let input = input.with_file_name(input.file_name().unwrap().to_string_lossy().replace('-', "_").as_str().trim());
         let input = input.as_path();
-        println!("Parsing library: {}", input.display());
         let identifier = self.identifier_parser.parse(input, config)?;
         let metadata = self.metadata_parser.parse(input, config)?;
         let root_module = self.parse(SubPath(input), config)?;
@@ -50,7 +49,6 @@ impl PythonParser {
 impl Parser<&std::path::Path> for PythonParser {
     type Output = Registry;
     fn parse(&self, input: &std::path::Path, config: &ParserConfig) -> Result<Self::Output> {
-        println!("Parsing: {}", input.display());
         let mut registry = Registry::new();
         let library = self.parse_library(input, config)?;
         for dependency in library.metadata.dependencies.iter().filter(|dependency| dependency.feature.is_none()) { // TODO: We need to support features.

ecosystem/python/parser/src/scope/mod.rs

@@ -146,7 +146,7 @@ impl PythonParser {
             if let Stmt::ClassDef(class) = statement {
                 match self.type_definition_parser.parse(statements.sub(class.clone()), config) {
                     Ok(type_definition) => types.push(type_definition),
-                    Err(error) => println!("Failed to parse type definition: {:?}", error)
+                    Err(error) => todo!("Failed to parse type definition: {:?}", error)
                 }
             }
         }

ecosystem/python/parser/src/types/type_/validator.rs

@@ -15,7 +15,6 @@ impl Validator for TypeValidator {
     fn validate(&self, type_: &mut Type, config: &ParserConfig) -> Result<()> {
         let name = type_.path.last().identifier.name.as_str();
         if config.get(Path::from("ligen::python::as-opaque").join(name)).is_some() {
-            println!("{}", type_.path);
             *type_ = Type::opaque();
         }
         Ok(())

ligen/parser/src/parser/universal/attributes/attribute/intermediary_attribute/mod.rs

@@ -7,7 +7,6 @@ pub(crate) enum IntermediaryAttribute {
 
 impl syn::parse::Parse for IntermediaryAttribute {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        println!("{}", input);
         if input.peek(syn::Lit) {
             input.parse().map(IntermediaryAttribute::Lit)
         } else {

ligen/parser/src/parser/universal/attributes/attribute/mod.rs

@@ -39,7 +39,6 @@ impl<T: LiteralParser> Parser<syn::ItemMacro> for AttributeParser<T> {
 impl<T: LiteralParser> Parser<syn::MetaList> for AttributeParser<T> {
     type Output = Attribute;
     fn parse(&self, meta_list: syn::MetaList, config: &ParserConfig) -> Result<Self::Output> {
-        println!("4");
         let path = PathParser::default().parse(meta_list.path.clone(), config)?;
         let inner = meta_list.tokens.into_iter().map(|token| token.to_string()).collect::<Vec<_>>().join("");
         let attributes = AttributesParser::<T>::default().parse(inner.as_str(), config)?;
@@ -126,7 +125,6 @@ impl<T: LiteralParser> Parser<syn::MetaNameValue> for AttributeParser<T> {
 impl<T: LiteralParser> Parser<syn::Meta> for AttributeParser<T> {
     type Output = Attribute;
     fn parse(&self, meta: syn::Meta, config: &ParserConfig) -> Result<Self::Output> {
-        println!("3");
         match meta {
             syn::Meta::Path(path) => self.parse(path, config),
             syn::Meta::List(list) => self.parse(list, config),
@@ -152,7 +150,6 @@ impl<T: LiteralParser> Parser<String> for AttributeParser<T> {
 impl<T: LiteralParser> Parser<IntermediaryAttribute> for AttributeParser<T> {
     type Output = Attribute;
     fn parse(&self, input: IntermediaryAttribute, config: &ParserConfig) -> Result<Self::Output> {
-        println!("2", );
         match input {
             IntermediaryAttribute::Meta(meta) => self.parse(meta, config),
             IntermediaryAttribute::Lit(lit) => self.parse(lit, config),

ligen/parser/src/parser/universal/attributes/mod.rs

@@ -29,7 +29,6 @@ impl<L: LiteralParser> Parser<&str> for AttributesParser<L>
 {
     type Output = Attributes;
     fn parse(&self, input: &str, config: &ParserConfig) -> Result<Self::Output> {
-        println!("{}", input);
         syn::parse_str::<syn2::punctuated::Punctuated<IntermediaryAttribute, syn::token::Comma>>(input)
             .map_err(|e| Error::Message(format!("Failed to parse attributes: {}. Input: {}", e, input)))
             .and_then(|input| self.parse(input.0, config))
@@ -51,7 +50,6 @@ impl<L: LiteralParser> Parser<syn::punctuated::Punctuated<IntermediaryAttribute,
 {
     type Output = Attributes;
     fn parse(&self, input: syn::punctuated::Punctuated<IntermediaryAttribute, syn::token::Comma>, config: &ParserConfig) -> Result<Self::Output> {
-        println!("??");
         let mut attributes = Vec::new();
         for attribute in input {
             attributes.push(self.attribute_parser.parse(attribute, config)?);

tools/cli/src/main.rs

@@ -31,8 +31,7 @@ fn main() -> Result<()> {
         panic!("Parser not found.");
     };
     let config = parser.config();
-    let registry = parser.parse(args.input.as_path(), &config)?;
-    println!("{:#?}", registry);
+    let _registry = parser.parse(args.input.as_path(), &config)?;
     // for library in registry.libraries.iter() {
     //     LibraryGenerator::default().generate(&library, PathBuf::from(&args.output).as_path())?;
     // }