fix path handling

Author: powerboat9

gcc/rust/ast/rust-ast-builder.cc

@@ -276,6 +276,63 @@ Builder::type_path (LangItem::Kind lang_item) const
   return type_path (type_path_segment (lang_item));
 }
 
+TypePath
+Builder::type_path_core (std::vector<std::unique_ptr<TypePathSegment>> &&segments) const
+{
+  bool opening_scope;
+
+  auto &mappings = Analysis::Mappings::get ();
+  if (mappings.get_current_crate_name () == "core")
+    {
+      segments.emplace (segments.cbegin (), type_path_segment ("crate"));
+      opening_scope = false;
+    }
+  else
+    {
+      segments.emplace (segments.cbegin (), type_path_segment ("core"));
+      opening_scope = true;
+    }
+
+  return TypePath (std::move (segments), loc, opening_scope);
+}
+
+TypePath
+Builder::type_path_core (std::vector<std::string> &&segments) const
+{
+  auto type_segments = std::vector<std::unique_ptr<TypePathSegment>> ();
+  type_segments.reserve (segments.size () + 1);
+  bool opening_scope;
+
+  auto &mappings = Analysis::Mappings::get ();
+  if (mappings.get_current_crate_name () == "core")
+    {
+      type_segments.emplace_back (type_path_segment ("crate"));
+      opening_scope = false;
+    }
+  else
+    {
+      type_segments.emplace_back (type_path_segment ("core"));
+      opening_scope = true;
+    }
+
+  for (auto &&seg : segments)
+    type_segments.emplace_back (type_path_segment (seg));
+
+  return TypePath (std::move (type_segments), loc, opening_scope);
+}
+
+TypePath
+Builder::type_path_core (std::initializer_list<const char *> segments) const
+{
+  std::vector<std::string> segments_out;
+  segments_out.reserve (segments.size ());
+
+  for (auto seg : segments)
+    segments_out.emplace_back (seg);
+
+  return type_path_core (std::move (segments_out));
+}
+
 std::unique_ptr<Type>
 Builder::reference_type (std::unique_ptr<TypeNoBounds> &&inner_type,
 			 bool mutability) const
@@ -301,6 +358,31 @@ Builder::path_in_expression (LangItem::Kind lang_item) const
   return PathInExpression (lang_item, {}, loc);
 }
 
+PathInExpression
+Builder::path_in_expression_core (std::vector<std::string> &&segments) const
+{
+  auto path_segments = std::vector<PathExprSegment> ();
+  path_segments.reserve (segments.size () + 1);
+  bool opening_scope;
+
+  auto &mappings = Analysis::Mappings::get ();
+  if (mappings.get_current_crate_name () == "core")
+    {
+      path_segments.emplace_back (path_segment ("crate"));
+      opening_scope = false;
+    }
+  else
+    {
+      path_segments.emplace_back (path_segment ("core"));
+      opening_scope = true;
+    }
+
+  for (auto &&seg : segments)
+    path_segments.emplace_back (path_segment (seg));
+
+  return PathInExpression (std::move (path_segments), {}, loc, opening_scope);
+}
+
 PathInExpression
 Builder::variant_path (const std::string &enum_path,
 		       const std::string &variant) const
@@ -544,7 +626,7 @@ std::unique_ptr<Stmt>
 Builder::discriminant_value (std::string binding_name, std::string instance)
 {
   auto intrinsic = ptrify (
-    path_in_expression ({"core", "intrinsics", "discriminant_value"}, true));
+    path_in_expression_core ({"intrinsics", "discriminant_value"}));
 
   return let (identifier_pattern (binding_name), nullptr,
 	      call (std::move (intrinsic), identifier (instance)));

gcc/rust/ast/rust-ast-builder.h

@@ -220,6 +220,14 @@ class Builder
   TypePath type_path (std::string type) const;
   TypePath type_path (LangItem::Kind lang_item) const;
 
+  /**
+   * Creates a type path relative to libcore
+   * Either `::core...` or `crate...`
+   */
+  TypePath type_path_core (std::vector<std::unique_ptr<TypePathSegment>> &&segments) const;
+  TypePath type_path_core (std::vector<std::string> &&segments) const;
+  TypePath type_path_core (std::initializer_list<const char *> segments) const;
+
   std::unique_ptr<Type>
   reference_type (std::unique_ptr<TypeNoBounds> &&inner_type,
 		  bool mutability = false) const;
@@ -237,6 +245,12 @@ class Builder
    */
   PathInExpression path_in_expression (LangItem::Kind lang_item) const;
 
+  /**
+   * Create a path in expression relative to libcore
+   * Either `::core...` or `crate...`
+   */
+  PathInExpression path_in_expression_core (std::vector<std::string> &&segments) const;
+
   /* Create the path to an enum's variant (`Result::Ok`) */
   PathInExpression variant_path (const std::string &enum_path,
 				 const std::string &variant) const;
@@ -331,11 +345,6 @@ class Builder
 
   /* Location of the generated AST nodes */
   location_t loc;
-
-private:
-  /* Some constexpr helpers for some of the builders */
-  static constexpr std::initializer_list<const char *> discriminant_value_path
-    = {"core", "intrinsics", "discriminant_value"};
 };
 
 } // namespace AST

gcc/rust/expand/rust-derive-debug.cc

@@ -55,10 +55,10 @@ DeriveDebug::stub_debug_fn ()
   auto self = builder.self_ref_param ();
 
   auto return_type
-    = ptrify (builder.type_path ({"core", "fmt", "Result"}, true));
+    = ptrify (builder.type_path_core ({"fmt", "Result"}));
 
   auto mut_fmt_type_inner
-    = ptrify (builder.type_path ({"core", "fmt", "Formatter"}, true));
+    = ptrify (builder.type_path_core ({"fmt", "Formatter"}));
 
   auto mut_fmt_type
     = builder.reference_type (std::move (mut_fmt_type_inner), true);
@@ -81,7 +81,7 @@ DeriveDebug::stub_derive_impl (
 {
   auto trait_items = vec (stub_debug_fn ());
 
-  auto debug = builder.type_path ({"core", "fmt", "Debug"}, true);
+  auto debug = builder.type_path_core ({"fmt", "Debug"});
   auto generics
     = setup_impl_generics (name, type_generics, builder.trait_bound (debug));
 

gcc/rust/expand/rust-derive-default.cc

@@ -42,7 +42,7 @@ DeriveDefault::go (Item &item)
 std::unique_ptr<Expr>
 DeriveDefault::default_call (std::unique_ptr<Type> &&type)
 {
-  auto default_trait = builder.type_path ({"core", "default", "Default"}, true);
+  auto default_trait = builder.type_path_core ({"default", "Default"});
 
   auto default_fn
     = builder.qualified_path_in_expression (std::move (type), default_trait,
@@ -69,7 +69,7 @@ DeriveDefault::default_impl (
   std::unique_ptr<AssociatedItem> &&default_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto default_path = builder.type_path ({"core", "default", "Default"}, true);
+  auto default_path = builder.type_path_core ({"default", "Default"});
 
   auto trait_items = vec (std::move (default_fn));
 

gcc/rust/expand/rust-derive-eq.cc

@@ -61,7 +61,7 @@ std::unique_ptr<Stmt>
 DeriveEq::assert_param_is_eq ()
 {
   auto eq_bound = std::unique_ptr<TypeParamBound> (
-    new TraitBound (builder.type_path ({"core", "cmp", "Eq"}, true), loc));
+    new TraitBound (builder.type_path_core ({"cmp", "Eq"}), loc));
 
   auto sized_bound = std::unique_ptr<TypeParamBound> (
     new TraitBound (builder.type_path (LangItem::Kind::SIZED), loc, false,
@@ -113,9 +113,9 @@ DeriveEq::eq_impls (
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
   // We create two copies of the type-path to avoid duplicate NodeIds
-  auto eq = builder.type_path ({"core", "cmp", "Eq"}, true);
+  auto eq = builder.type_path_core ({"cmp", "Eq"});
   auto eq_bound
-    = builder.trait_bound (builder.type_path ({"core", "cmp", "Eq"}, true));
+    = builder.trait_bound (builder.type_path_core ({"cmp", "Eq"}));
 
   auto steq = builder.type_path (LangItem::Kind::STRUCTURAL_TEQ);
 

gcc/rust/expand/rust-derive-hash.cc

@@ -42,7 +42,7 @@ std::unique_ptr<Expr>
 DeriveHash::hash_call (std::unique_ptr<Expr> &&value)
 {
   auto hash
-    = builder.path_in_expression ({"core", "hash", "Hash", "hash"}, true);
+    = builder.path_in_expression_core ({"hash", "Hash", "hash"});
 
   return builder.call (ptrify (hash),
 		       vec (std::move (value),
@@ -64,7 +64,7 @@ DeriveHash::hash_fn (std::unique_ptr<BlockExpr> &&block)
 
   auto params = vec (builder.self_ref_param (), std::move (state_param));
   auto bounds = vec (
-    builder.trait_bound (builder.type_path ({"core", "hash", "Hasher"}, true)));
+    builder.trait_bound (builder.type_path_core ({"hash", "Hasher"})));
   auto generics = vec (
     builder.generic_type_param (DeriveHash::state_type, std::move (bounds)));
 
@@ -77,7 +77,7 @@ DeriveHash::hash_impl (
   std::unique_ptr<AssociatedItem> &&hash_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto hash_path = builder.type_path ({"core", "hash", "Hash"}, true);
+  auto hash_path = builder.type_path_core ({"hash", "Hash"});
 
   auto trait_items = vec (std::move (hash_fn));
 

gcc/rust/expand/rust-derive-ord.cc

@@ -42,8 +42,8 @@ std::unique_ptr<Expr>
 DeriveOrd::cmp_call (std::unique_ptr<Expr> &&self_expr,
 		     std::unique_ptr<Expr> &&other_expr)
 {
-  auto cmp_fn_path = builder.path_in_expression (
-    {"core", "cmp", trait (ordering), fn (ordering)}, true);
+  auto cmp_fn_path = builder.path_in_expression_core (
+    {"cmp", trait (ordering), fn (ordering)});
 
   return builder.call (ptrify (cmp_fn_path),
 		       vec (builder.ref (std::move (self_expr)),
@@ -58,10 +58,10 @@ DeriveOrd::cmp_impl (
   auto fn = cmp_fn (std::move (fn_block), type_name);
 
   auto trait = ordering == Ordering::Partial ? "PartialOrd" : "Ord";
-  auto trait_path = builder.type_path ({"core", "cmp", trait}, true);
+  auto trait_path = builder.type_path_core ({"cmp", trait});
 
   auto trait_bound
-    = builder.trait_bound (builder.type_path ({"core", "cmp", trait}, true));
+    = builder.trait_bound (builder.type_path_core ({"cmp", trait}));
 
   auto trait_items = vec (std::move (fn));
 
@@ -78,7 +78,7 @@ std::unique_ptr<AssociatedItem>
 DeriveOrd::cmp_fn (std::unique_ptr<BlockExpr> &&block, Identifier type_name)
 {
   // Ordering
-  auto return_type = builder.type_path ({"core", "cmp", "Ordering"}, true);
+  auto return_type = builder.type_path_core ({"cmp", "Ordering"});
 
   // In the case of PartialOrd, we return an Option<Ordering>
   if (ordering == Ordering::Partial)
@@ -87,13 +87,11 @@ DeriveOrd::cmp_fn (std::unique_ptr<BlockExpr> &&block, Identifier type_name)
 
       auto generic_seg = builder.type_path_segment_generic (
 	"Option", GenericArgs ({}, {generic}, {}, loc));
-      auto core = builder.type_path_segment ("core");
       auto option = builder.type_path_segment ("option");
 
       return_type
-	= builder.type_path (vec (std::move (core), std::move (option),
-				  std::move (generic_seg)),
-			     true);
+	= builder.type_path_core (vec (std::move (option),
+				  std::move (generic_seg)));
     }
 
   // &self, other: &Self
@@ -113,7 +111,7 @@ std::unique_ptr<Pattern>
 DeriveOrd::make_equal ()
 {
   std::unique_ptr<Pattern> equal = ptrify (
-    builder.path_in_expression ({"core", "cmp", "Ordering", "Equal"}, true));
+    builder.path_in_expression_core ({"cmp", "Ordering", "Equal"}));
 
   // We need to wrap the pattern in Option::Some if we are doing partial
   // ordering
@@ -148,8 +146,7 @@ DeriveOrd::recursive_match (std::vector<SelfOther> &&members)
   if (members.empty ())
     {
       std::unique_ptr<Expr> value = ptrify (
-	builder.path_in_expression ({"core", "cmp", "Ordering", "Equal"},
-				    true));
+	builder.path_in_expression_core ({"cmp", "Ordering", "Equal"}));
 
       if (ordering == Ordering::Partial)
 	value = builder.call (ptrify (builder.path_in_expression (

gcc/rust/expand/rust-expand-format-args.cc

@@ -36,10 +36,10 @@ format_arg (const AST::Builder &builder, std::unique_ptr<AST::Expr> &&to_format,
 	    const std::string &trait)
 {
   auto formatter_fn = std::unique_ptr<AST::Expr> (new AST::PathInExpression (
-    builder.path_in_expression ({"core", "fmt", trait, "fmt"})));
+    builder.path_in_expression_core ({"fmt", trait, "fmt"})));
 
   auto path = std::unique_ptr<AST::Expr> (new AST::PathInExpression (
-    builder.path_in_expression ({"core", "fmt", "ArgumentV1", "new"})));
+    builder.path_in_expression_core ({"fmt", "ArgumentV1", "new"})));
 
   auto args = std::vector<std::unique_ptr<AST::Expr>> ();
   args.emplace_back (std::move (to_format));
@@ -123,7 +123,7 @@ expand_format_args (AST::FormatArgs &fmt,
   auto args_slice = builder.ref (builder.array (std::move (args_array)));
 
   auto final_path = std::make_unique<AST::PathInExpression> (
-    builder.path_in_expression ({"core", "fmt", "Arguments", "new_v1"}));
+    builder.path_in_expression_core ({"fmt", "Arguments", "new_v1"}));
   auto final_args = std::vector<std::unique_ptr<AST::Expr>> ();
   final_args.emplace_back (std::move (pieces));
   final_args.emplace_back (std::move (args_slice));