Added more cfg stripping code

1 files changed, 147 insertions, 20 deletions

diff --git a/gcc/rust/expand/rust-macro-expand.cc b/gcc/rust/expand/rust-macro-expand.cc
index 2fe84cb..95fb962 100644
--- a/gcc/rust/expand/rust-macro-expand.cc
+++ b/gcc/rust/expand/rust-macro-expand.cc
@@ -2349,6 +2349,7 @@ namespace Rust {
             }
         }
 
+        // I don't think it would be possible to strip macros without expansion
         void visit(AST::MacroMatchFragment& match) override {}
         void visit(AST::MacroMatchRepetition& match) override {}
         void visit(AST::MacroMatcher& matcher) override {}
@@ -2401,13 +2402,23 @@ namespace Rust {
             // not possible
         }
         void visit(AST::RangePatternBoundPath& bound) override {
-            // TODO: maybe possible if path is possible
+            // can expand path, but not strip it directly
+            auto& path = bound.get_path();
+            visit(path);
+            if (path.is_marked_for_strip())
+                rust_error_at(path.get_locus(), "cannot strip path in this position");
         }
         void visit(AST::RangePatternBoundQualPath& bound) override {
-            // TODO: maybe possible if path is possible
+            // can expand path, but not strip it directly
+            auto& path = bound.get_qualified_path();
+            visit(path);
+            if (path.is_marked_for_strip())
+                rust_error_at(path.get_locus(), "cannot strip path in this position");
         }
         void visit(AST::RangePattern& pattern) override {
-            // TODO: possible if any bounds are possible
+            // should have no capability to strip lower or upper bounds, only expand
+            pattern.get_lower_bound()->accept_vis(*this);
+            pattern.get_upper_bound()->accept_vis(*this);
         }
         void visit(AST::ReferencePattern& pattern) override {
             auto& sub_pattern = pattern.get_referenced_pattern();
@@ -2452,6 +2463,12 @@ namespace Rust {
             }
         }
         void visit(AST::StructPattern& pattern) override {
+            // expand (but don't strip) path
+            auto& path = pattern.get_path();
+            visit(path);
+            if (path.is_marked_for_strip())
+                rust_error_at(path.get_locus(), "cannot strip path in this position");
+
             // TODO: apparently struct pattern fields can have outer attrs. so can they be stripped?
             if (!pattern.has_struct_pattern_elems())
                 return;
@@ -2506,7 +2523,11 @@ namespace Rust {
             }
         }
         void visit(AST::TupleStructPattern& pattern) override {
-            // TODO: stripping of path?
+            // expand (but don't strip) path
+            auto& path = pattern.get_path();
+            visit(path);
+            if (path.is_marked_for_strip())
+                rust_error_at(path.get_locus(), "cannot strip path in this position");
 
             if (pattern.has_items()) 
                 pattern.get_items()->accept_vis(*this);
@@ -2578,6 +2599,14 @@ namespace Rust {
             pattern->accept_vis(*this);
             if (pattern->is_marked_for_strip())
                 rust_error_at(pattern->get_locus_slow(), "cannot strip pattern in this position");
+            
+            // similar for type
+            if (stmt.has_type()) {
+                auto& type = stmt.get_type();
+                type->accept_vis(*this);
+                if (type->is_marked_for_strip())
+                    rust_error_at(type->get_locus_slow(), "cannot strip type in this position");
+            }
 
             /* strip any internal sub-expressions - expression itself isn't
              * allowed to have external attributes in this position so can't be
@@ -2621,25 +2650,123 @@ namespace Rust {
             }
         }
 
-        // stripping shouldn't be required or possible for types
-        void visit(AST::TraitBound& bound) override {}
-        void visit(AST::ImplTraitType& type) override {}
-        void visit(AST::TraitObjectType& type) override {}
-        void visit(AST::ParenthesisedType& type) override {}
-        void visit(AST::ImplTraitTypeOneBound& type) override {}
-        void visit(AST::TraitObjectTypeOneBound& type) override {}
-        void visit(AST::TupleType& type) override {}
-        void visit(AST::NeverType& type) override {}
-        void visit(AST::RawPointerType& type) override {}
-        void visit(AST::ReferenceType& type) override {}
+        void visit(AST::TraitBound& bound) override {
+            // nothing in for lifetimes to strip
+            
+            // expand but don't strip type path
+            auto& path = bound.get_type_path();
+            visit(path);
+            if (path.is_marked_for_strip())
+                rust_error_at(path.get_locus(), "cannot strip type path in this position");
+        }
+        void visit(AST::ImplTraitType& type) override {
+            // don't strip directly, only components of bounds
+            for (auto& bound : type.get_type_param_bounds()) 
+                bound->accept_vis(*this);
+        }
+        void visit(AST::TraitObjectType& type) override {
+            // don't strip directly, only components of bounds
+            for (auto& bound : type.get_type_param_bounds()) 
+                bound->accept_vis(*this);
+        }
+        void visit(AST::ParenthesisedType& type) override {
+            // expand but don't strip inner type
+            auto& inner_type = type.get_type_in_parens();
+            inner_type->accept_vis(*this);
+            if (inner_type->is_marked_for_strip())
+                rust_error_at(inner_type->get_locus_slow(), "cannot strip type in this position");
+        }
+        void visit(AST::ImplTraitTypeOneBound& type) override {
+            // no stripping possible
+            visit(type.get_trait_bound());
+        }
+        void visit(AST::TraitObjectTypeOneBound& type) override {
+            // no stripping possible
+            visit(type.get_trait_bound());
+        }
+        void visit(AST::TupleType& type) override {
+            // TODO: assuming that types can't be stripped as types don't have outer attributes
+            for (auto& elem_type : type.get_elems()) {
+                elem_type->accept_vis(*this);
+                if (elem_type->is_marked_for_strip())
+                    rust_error_at(elem_type->get_locus_slow(), "cannot strip type in this position");
+            }
+        }
+        void visit(AST::NeverType& type) override {
+            // no stripping possible
+        }
+        void visit(AST::RawPointerType& type) override {
+            // expand but don't strip type pointed to
+            auto& pointed_type = type.get_type_pointed_to();
+            pointed_type->accept_vis(*this);
+            if (pointed_type->is_marked_for_strip())
+                rust_error_at(pointed_type->get_locus_slow(), "cannot strip type in this position");
+        }
+        void visit(AST::ReferenceType& type) override {
+            // expand but don't strip type referenced
+            auto& referenced_type = type.get_type_referenced();
+            referenced_type->accept_vis(*this);
+            if (referenced_type->is_marked_for_strip())
+                rust_error_at(referenced_type->get_locus_slow(), "cannot strip type in this position");
+        }
         void visit(AST::ArrayType& type) override {
-            // TODO: array type contains a "constant expression" - could this have strippable sub-exprs?
+            // expand but don't strip type referenced
+            auto& base_type = type.get_elem_type();
+            base_type->accept_vis(*this);
+            if (base_type->is_marked_for_strip())
+                rust_error_at(base_type->get_locus_slow(), "cannot strip type in this position");
+            
+            // same for expression
+            auto& size_expr = type.get_size_expr();
+            size_expr->accept_vis(*this);
+            if (size_expr->is_marked_for_strip())
+                rust_error_at(size_expr->get_locus_slow(), "cannot strip expression in this position");
+        }
+        void visit(AST::SliceType& type) override {
+            // expand but don't strip elem type
+            auto& elem_type = type.get_elem_type();
+            elem_type->accept_vis(*this);
+            if (elem_type->is_marked_for_strip())
+                rust_error_at(elem_type->get_locus_slow(), "cannot strip type in this position");
+        }
+        void visit(AST::InferredType& type) override {
+            // none possible
         }
-        void visit(AST::SliceType& type) override {}
-        void visit(AST::InferredType& type) override {}
         void visit(AST::BareFunctionType& type) override {
-            // TODO: bare function type contains "maybe-named params" that have outer attributes - could this be strippable?
-            // apparently "attribute rules are same as on regular function params", so looks like a yes
+            // seem to be no generics
+
+            // presumably function params can be stripped
+            auto& params = type.get_function_params();
+            for (int i = 0; i < params.size();) {
+                auto& param = params[i];
+
+                auto& param_attrs = param.get_outer_attrs();
+                expander.expand_cfg_attrs(param_attrs);
+                if (expander.fails_cfg(param_attrs)) {
+                    params.erase(params.begin() + i);
+                    continue;
+                }
+
+                auto& type = param.get_type();
+                type->accept_vis(*this);
+                if (type->is_marked_for_strip())
+                    rust_error_at(type->get_locus_slow(), "cannot strip type in this position");
+                
+                // increment if nothing else happens
+                i++;
+            }
+
+            /* TODO: assuming that variadic nature cannot be stripped. If this
+             * is not true, then have code here to do so. */
+            
+            if (type.has_return_type()) {
+                auto& return_type = type.get_return_type();
+                return_type->accept_vis(*this);
+                if (return_type->is_marked_for_strip())
+                    rust_error_at(return_type->get_locus_slow(), "cannot strip type in this position");
+            }
+            
+            // no where clause, apparently
         }
     };