Enable skip multi passes.

   Also change option to --skip-pass, format like other options.

Author: redbopo

src/bin/lpython.cpp

@@ -903,7 +903,7 @@ int main(int argc, char *argv[])
         app.add_flag("--indent", compiler_options.indent, "Indented print ASR/AST");
         app.add_flag("--tree", compiler_options.tree, "Tree structure print ASR/AST");
         app.add_option("--pass", arg_pass, "Apply the ASR pass and show ASR (implies --show-asr)");
-        app.add_option("--skip_pass", skip_pass, "Skip an ASR pass in default pipeline");
+        app.add_option("--skip-pass", skip_pass, "Skip an ASR pass in default pipeline");
         app.add_flag("--disable-main", compiler_options.disable_main, "Do not generate any code for the `main` function");
         app.add_flag("--symtab-only", compiler_options.symtab_only, "Only create symbol tables in ASR (skip executable stmt)");
         app.add_flag("--time-report", time_report, "Show compilation time report");

src/libasr/pass/pass_manager.h

@@ -40,6 +40,7 @@
 
 #include <map>
 #include <vector>
+#include <algorithm>
 
 namespace LCompilers {
 
@@ -52,6 +53,7 @@ namespace LCompilers {
         std::vector<std::string> _passes;
         std::vector<std::string> _with_optimization_passes;
         std::vector<std::string> _user_defined_passes;
+        std::vector<std::string> _skip_passes;
         std::map<std::string, pass_function> _passes_db = {
             {"do_loops", &LFortran::pass_replace_do_loops},
             {"global_stmts", &LFortran::pass_wrap_global_stmts_into_function},
@@ -77,20 +79,45 @@ namespace LCompilers {
 
         bool is_fast;
         bool apply_default_passes;
-        std::string skip_pass;
 
         void _apply_passes(Allocator& al, LFortran::ASR::TranslationUnit_t* asr,
                            std::vector<std::string>& passes, PassOptions pass_options) {
             pass_options.runtime_library_dir = LFortran::get_runtime_library_dir();
             for (size_t i = 0; i < passes.size(); i++) {
-                if (passes[i] == skip_pass) continue;
+                if( std::find(_skip_passes.begin(), _skip_passes.end(), passes[i]) != _skip_passes.end())
+                    continue;
                 _passes_db[passes[i]](al, *asr, pass_options);
             }
         }
 
+        void _parse_pass_arg(std::string& arg, std::vector<std::string>& passes) {
+            if (arg == "") return;
+
+            std::string current_pass = "";
+            for( size_t i = 0; i < arg.size(); i++ ) {
+                char ch = arg[i];
+                if (ch != ' ' && ch != ',') {
+                    current_pass.push_back(ch);
+                }
+                if (ch == ',' || i == arg.size() - 1) {
+                    current_pass = LFortran::to_lower(current_pass);
+                    if( _passes_db.find(current_pass) == _passes_db.end() ) {
+                        std::cerr << current_pass << " isn't supported yet.";
+                        std::cerr << " Only the following passes are supported:- "<<std::endl;
+                        for( auto it: _passes_db ) {
+                            std::cerr << it.first << std::endl;
+                        }
+                        exit(1);
+                    }
+                    passes.push_back(current_pass);
+                    current_pass.clear();
+                }
+            }
+        }
+
         public:
 
-        PassManager(): is_fast{false}, apply_default_passes{false}, skip_pass("") {
+        PassManager(): is_fast{false}, apply_default_passes{false} {
             _passes = {
                 "global_stmts",
                 "class_constructor",
@@ -131,35 +158,15 @@ namespace LCompilers {
             };
 
             _user_defined_passes.clear();
+            _skip_passes.clear();
         }
 
-        void parse_pass_arg(std::string& arg_pass, std::string& s_pass) {
+        void parse_pass_arg(std::string& arg_pass, std::string& skip_pass) {
             _user_defined_passes.clear();
-            skip_pass = s_pass;
-            if (arg_pass == "") {
-                return ;
-            }
+            _skip_passes.clear();
 
-            std::string current_pass = "";
-            for( size_t i = 0; i < arg_pass.size(); i++ ) {
-                char ch = arg_pass[i];
-                if (ch != ' ' && ch != ',') {
-                    current_pass.push_back(ch);
-                }
-                if (ch == ',' || i == arg_pass.size() - 1) {
-                    current_pass = LFortran::to_lower(current_pass);
-                    if( _passes_db.find(current_pass) == _passes_db.end() ) {
-                        std::cerr << current_pass << " isn't supported yet.";
-                        std::cerr << " Only the following passes are supported:- "<<std::endl;
-                        for( auto it: _passes_db ) {
-                            std::cerr << it.first << std::endl;
-                        }
-                        exit(1);
-                    }
-                    _user_defined_passes.push_back(current_pass);
-                    current_pass.clear();
-                }
-            }
+            _parse_pass_arg(arg_pass, _user_defined_passes);
+            _parse_pass_arg(skip_pass, _skip_passes);
         }
 
         void apply_passes(Allocator& al, LFortran::ASR::TranslationUnit_t* asr,