Nr2 fix privacy path

gcc/rust/ast/rust-ast-collector.cc

@@ -245,7 +245,7 @@ TokenCollector::visit (Visibility &vis)
       push (Rust::Token::make (PUB, vis.get_locus ()));
       push (Rust::Token::make (LEFT_PAREN, UNDEF_LOCATION));
       push (Rust::Token::make (IN, UNDEF_LOCATION));
-      visit (vis.get_path ());
+      visit (vis.get_path_unchecked ());
       push (Rust::Token::make (RIGHT_PAREN, UNDEF_LOCATION));
       break;
     case Visibility::PRIV:

gcc/rust/ast/rust-ast-visitor.cc

@@ -755,7 +755,8 @@ DefaultASTVisitor::visit (AST::TypeBoundWhereClauseItem &item)
 void
 DefaultASTVisitor::visit (AST::Visibility &vis)
 {
-  visit (vis.get_path ());
+  if (vis.has_path ())
+    visit (vis.get_path_unchecked ());
 }
 
 void

gcc/rust/ast/rust-ast.cc

@@ -453,7 +453,8 @@ Visibility::as_string () const
     case PUB_SUPER:
       return std::string ("pub(super)");
     case PUB_IN_PATH:
-      return std::string ("pub(in ") + in_path.as_string () + std::string (")");
+      return std::string ("pub(in ") + get_path_unchecked ().as_string ()
+	     + std::string (")");
     default:
       rust_unreachable ();
     }

gcc/rust/ast/rust-ast.h

@@ -497,41 +497,31 @@ struct Visibility
 private:
   VisType vis_type;
   // Only assigned if vis_type is IN_PATH
-  SimplePath in_path;
+  tl::optional<SimplePath> in_path;
   location_t locus;
 
   // should this store location info?
 
-public:
   // Creates a Visibility - TODO make constructor protected or private?
-  Visibility (VisType vis_type, SimplePath in_path, location_t locus)
+  Visibility (VisType vis_type, tl::optional<SimplePath> in_path,
+	      location_t locus)
     : vis_type (vis_type), in_path (std::move (in_path)), locus (locus)
   {}
 
+public:
   VisType get_vis_type () const { return vis_type; }
 
-  // Returns whether visibility is in an error state.
-  bool is_error () const
+  // Returns whether a visibility has a path
+  bool has_path () const
   {
-    return vis_type == PUB_IN_PATH && in_path.is_empty ();
+    return in_path.has_value () && vis_type >= PUB_CRATE;
   }
 
-  // Returns whether a visibility has a path
-  bool has_path () const { return !is_error () && vis_type >= PUB_CRATE; }
-
   // Returns whether visibility is public or not.
-  bool is_public () const { return vis_type != PRIV && !is_error (); }
+  bool is_public () const { return vis_type != PRIV; }
 
   location_t get_locus () const { return locus; }
 
-  // empty?
-  // Creates an error visibility.
-  static Visibility create_error ()
-  {
-    return Visibility (PUB_IN_PATH, SimplePath::create_empty (),
-		       UNDEF_LOCATION);
-  }
-
   // Unique pointer custom clone function
   /*std::unique_ptr<Visibility> clone_visibility() const {
       return std::unique_ptr<Visibility>(clone_visibility_impl());
@@ -591,8 +581,8 @@ struct Visibility
   }
 
   std::string as_string () const;
-  const SimplePath &get_path () const { return in_path; }
-  SimplePath &get_path () { return in_path; }
+  const SimplePath &get_path_unchecked () const { return in_path.value (); }
+  SimplePath &get_path_unchecked () { return in_path.value (); }
 
 protected:
   // Clone function implementation - not currently virtual but may be if

gcc/rust/ast/rust-item.h

@@ -807,7 +807,7 @@ class Module : public VisItem
   // Loaded module constructor, with items
   Module (Identifier name, location_t locus,
 	  std::vector<std::unique_ptr<Item>> items,
-	  Visibility visibility = Visibility::create_error (),
+	  Visibility visibility = Visibility::create_private (),
 	  Unsafety safety = Unsafety::Normal,
 	  std::vector<Attribute> inner_attrs = std::vector<Attribute> (),
 	  std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
@@ -1727,7 +1727,7 @@ class StructField
   bool has_outer_attributes () const { return !outer_attrs.empty (); }
 
   // Returns whether struct field has a non-private (non-default) visibility.
-  bool has_visibility () const { return !visibility.is_error (); }
+  bool has_visibility () const { return visibility.is_public (); }
 
   StructField (Identifier field_name, std::unique_ptr<Type> field_type,
 	       Visibility vis, location_t locus,
@@ -1781,8 +1781,8 @@ class StructField
   // Creates an error state struct field.
   static StructField create_error ()
   {
-    return StructField (std::string (""), nullptr, Visibility::create_error (),
-			UNDEF_LOCATION);
+    return StructField (std::string (""), nullptr,
+			Visibility::create_private (), UNDEF_LOCATION);
   }
 
   std::string as_string () const;
@@ -1886,7 +1886,7 @@ class TupleField
 
   /* Returns whether tuple field has a non-default visibility (i.e. a public
    * one) */
-  bool has_visibility () const { return !visibility.is_error (); }
+  bool has_visibility () const { return visibility.is_public (); }
 
   // Complete constructor
   TupleField (std::unique_ptr<Type> field_type, Visibility vis,
@@ -1936,7 +1936,7 @@ class TupleField
   // Creates an error state tuple field.
   static TupleField create_error ()
   {
-    return TupleField (nullptr, Visibility::create_error (), UNDEF_LOCATION);
+    return TupleField (nullptr, Visibility::create_private (), UNDEF_LOCATION);
   }
 
   std::string as_string () const;
@@ -3466,7 +3466,7 @@ class ExternalTypeItem : public ExternalItem
   bool has_outer_attrs () const { return !outer_attrs.empty (); }
 
   // Returns whether item has non-default visibility.
-  bool has_visibility () const { return !visibility.is_error (); }
+  bool has_visibility () const { return visibility.is_public (); }
 
   location_t get_locus () const { return locus; }
 
@@ -3558,7 +3558,7 @@ class ExternalStaticItem : public ExternalItem
   bool has_outer_attrs () const { return !outer_attrs.empty (); }
 
   // Returns whether item has non-default visibility.
-  bool has_visibility () const { return !visibility.is_error (); }
+  bool has_visibility () const { return visibility.is_public (); }
 
   location_t get_locus () const { return locus; }
 

gcc/rust/ast/rust-macro.h

@@ -524,7 +524,7 @@ class MacroRulesDefinition : public VisItem
     return std::make_unique<MacroRulesDefinition> (
       MacroRulesDefinition (rule_name, delim_type, rules, outer_attrs, locus,
 			    AST::MacroRulesDefinition::MacroKind::MBE,
-			    AST::Visibility::create_error ()));
+			    AST::Visibility::create_private ()));
   }
 
   static std::unique_ptr<MacroRulesDefinition>

gcc/rust/hir/rust-ast-lower.cc

@@ -34,13 +34,6 @@ using HIR::ClosureParam;
 Visibility
 translate_visibility (const AST::Visibility &vis)
 {
-  // FIXME: How do we create a private visibility here? Is it always private if
-  // the AST vis is an error?
-  // FIXME: We need to add a `create_private()` static function to the
-  // AST::Visibility class and use it when the vis is empty in the parser...
-  if (vis.is_error ())
-    return Visibility::create_error ();
-
   switch (vis.get_vis_type ())
     {
     case AST::Visibility::PUB:
@@ -52,7 +45,8 @@ translate_visibility (const AST::Visibility &vis)
     case AST::Visibility::PUB_SUPER:
     case AST::Visibility::PUB_IN_PATH:
       return Visibility (Visibility::VisType::RESTRICTED,
-			 ASTLoweringSimplePath::translate (vis.get_path ()),
+			 ASTLoweringSimplePath::translate (
+			   vis.get_path_unchecked ()),
 			 vis.get_locus ());
       break;
     }

gcc/rust/parse/rust-parse-impl.h

@@ -2414,7 +2414,7 @@ Parser<ManagedTokenSource>::parse_visibility ()
 	    add_error (std::move (error));
 
 	    // skip after somewhere?
-	    return AST::Visibility::create_error ();
+	    return AST::Visibility::create_private ();
 	  }
 
 	skip_token (RIGHT_PAREN);
@@ -2426,7 +2426,7 @@ Parser<ManagedTokenSource>::parse_visibility ()
 			t->get_token_description ()));
 
       lexer.skip_token ();
-      return AST::Visibility::create_error ();
+      return AST::Visibility::create_private ();
     }
 }
 

gcc/rust/resolve/rust-ast-resolve-base.cc

@@ -30,7 +30,7 @@ ResolverBase::resolve_visibility (const AST::Visibility &vis)
 {
   if (vis.has_path ())
     {
-      auto path = vis.get_path ();
+      auto path = vis.get_path_unchecked ();
       ResolvePath::go (path);
 
       // Do we need to lookup something here?

gcc/rust/resolve/rust-early-name-resolver-2.0.cc

@@ -272,7 +272,11 @@ Early::visit (AST::MacroInvocation &invoc)
   // we won't have changed `definition` from `nullopt` if there are more
   // than one segments in our path
   if (!definition.has_value ())
-    definition = ctx.resolve_path (path.get_segments (), Namespace::Macros);
+    {
+      if (auto resolved
+	  = ctx.resolve_path (path.get_segments (), Namespace::Macros))
+	definition = resolved.value ();
+    }
 
   // if the definition still does not have a value, then it's an error
   if (!definition.has_value ())

gcc/rust/resolve/rust-forever-stack.h

@@ -543,6 +543,23 @@ class ForeverStackStore
   Node root;
 };
 
+class ResolutionError
+{
+  location_t offending_location;
+  std::vector<Identifier> suggestions;
+
+  ResolutionError (location_t loc, std::vector<Identifier> suggestions)
+    : offending_location (loc), suggestions (suggestions)
+  {}
+
+public:
+  static ResolutionError make_error (location_t loc,
+				     std::vector<Identifier> suggestions = {})
+  {
+    return ResolutionError (loc, suggestions);
+  }
+};
+
 template <Namespace N> class ForeverStack
 {
 public:
@@ -671,7 +688,7 @@ template <Namespace N> class ForeverStack
    *         current map, an empty one otherwise.
    */
   template <typename S>
-  tl::optional<Rib::Definition> resolve_path (
+  tl::expected<Rib::Definition, ResolutionError> resolve_path (
     const std::vector<S> &segments, bool has_opening_scope_resolution,
     std::function<void (const S &, NodeId)> insert_segment_resolution,
     std::vector<Error> &collect_errors);
@@ -790,14 +807,14 @@ template <Namespace N> class ForeverStack
   Node &find_closest_module (Node &starting_point);
 
   template <typename S>
-  tl::optional<SegIterator<S>> find_starting_point (
+  tl::expected<SegIterator<S>, ResolutionError> find_starting_point (
     const std::vector<S> &segments,
     std::reference_wrapper<Node> &starting_point,
     std::function<void (const S &, NodeId)> insert_segment_resolution,
     std::vector<Error> &collect_errors);
 
   template <typename S>
-  tl::optional<Node &> resolve_segments (
+  tl::expected<std::reference_wrapper<Node>, ResolutionError> resolve_segments (
     Node &starting_point, const std::vector<S> &segments,
     SegIterator<S> iterator,
     std::function<void (const S &, NodeId)> insert_segment_resolution,