[WIP] Compile libcore

gcc/rust/ChangeLog

@@ -2775,7 +2775,7 @@
 
 2025-03-21  Owen Avery  <[email protected]>
 
-	* resolve/rust-name-resolver.cc: Include options.txt.
+	* resolve/rust-name-resolver.cc: Include options.h.
 	(Resolver::insert_resolved_name): Assert that name resolution
 	2.0 is disabled.
 	(Resolver::lookup_resolved_name): Likewise.

gcc/rust/Make-lang.in

@@ -144,17 +144,7 @@ GRS_OBJS = \
 	rust/rust-ice-finalizer.o \
     rust/rust-late-name-resolver-2.0.o \
 	rust/rust-immutable-name-resolution-context.o \
-    rust/rust-early-name-resolver.o \
     rust/rust-name-resolver.o \
-    rust/rust-ast-resolve.o \
-    rust/rust-ast-resolve-base.o \
-    rust/rust-ast-resolve-item.o \
-    rust/rust-ast-resolve-pattern.o \
-    rust/rust-ast-resolve-expr.o \
-    rust/rust-ast-resolve-type.o \
-    rust/rust-ast-resolve-path.o \
-    rust/rust-ast-resolve-stmt.o \
-    rust/rust-ast-resolve-struct-expr-field.o \
     rust/rust-forever-stack.o \
     rust/rust-hir-type-check.o \
     rust/rust-privacy-check.o \

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/ast/rust-ast-collector.cc

@@ -840,13 +840,13 @@ TokenCollector::visit (MetaItemLitExpr &item)
 }
 
 void
-TokenCollector::visit (MetaItemPathLit &item)
+TokenCollector::visit (MetaItemPathExpr &item)
 {
   auto path = item.get_path ();
-  auto lit = item.get_literal ();
+  auto &expr = item.get_expr ();
   visit (path);
-  push (Rust::Token::make (COLON, item.get_locus ()));
-  visit (lit);
+  push (Rust::Token::make (EQUAL, item.get_locus ()));
+  visit (expr);
 }
 
 void
@@ -3013,6 +3013,13 @@ TokenCollector::visit (AST::FormatArgs &fmt)
 		 __FILE__, __LINE__);
 }
 
+void
+TokenCollector::visit (AST::FormatArgsEager &fmt)
+{
+  rust_sorry_at (fmt.get_locus (), "%s:%u: unimplemented FormatArgsEager visitor",
+		 __FILE__, __LINE__);
+}
+
 void
 TokenCollector::visit (AST::OffsetOf &offset_of)
 {

gcc/rust/ast/rust-ast-collector.h

@@ -246,7 +246,7 @@ class TokenCollector : public ASTVisitor
   void visit (AttrInputLiteral &attr_input);
   void visit (AttrInputMacro &attr_input);
   void visit (MetaItemLitExpr &meta_item);
-  void visit (MetaItemPathLit &meta_item);
+  void visit (MetaItemPathExpr &meta_item);
   void visit (BorrowExpr &expr);
   void visit (DereferenceExpr &expr);
   void visit (ErrorPropagationExpr &expr);
@@ -405,6 +405,7 @@ class TokenCollector : public ASTVisitor
   void visit (BareFunctionType &type);
 
   void visit (FormatArgs &fmt);
+  void visit (FormatArgsEager &fmt);
   void visit (OffsetOf &offset_of);
 };
 } // namespace AST

gcc/rust/ast/rust-ast-full-decls.h

@@ -78,7 +78,7 @@ class LiteralExpr;
 class AttrInputLiteral;
 class AttrInputMacro;
 class MetaItemLitExpr;
-class MetaItemPathLit;
+class MetaItemPathExpr;
 class OperatorExpr;
 class BorrowExpr;
 class DereferenceExpr;
@@ -272,6 +272,7 @@ class BareFunctionType;
 
 // rust-builtin-ast-nodes.h
 class FormatArgs;
+class FormatArgsEager;
 } // namespace AST
 } // namespace Rust
 

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

@@ -224,10 +224,10 @@ DefaultASTVisitor::visit (AST::SimplePath &path)
 }
 
 void
-DefaultASTVisitor::visit (AST::MetaItemPathLit &meta_item)
+DefaultASTVisitor::visit (AST::MetaItemPathExpr &meta_item)
 {
   visit (meta_item.get_path ());
-  visit (meta_item.get_literal ());
+  visit (meta_item.get_expr ());
 }
 
 void
@@ -1505,6 +1505,15 @@ DefaultASTVisitor::visit (AST::FormatArgs &)
   // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
 }
 
+void
+DefaultASTVisitor::visit (AST::FormatArgsEager &fmt)
+{
+  // FIXME: Do we have anything to do? any subnodes to visit? Probably, right?
+
+  // we need this to resolve/expand macros, at least
+  visit (fmt.get_template ());
+}
+
 void
 DefaultASTVisitor::visit (AST::OffsetOf &offset_of)
 {

gcc/rust/ast/rust-ast-visitor.h

@@ -73,7 +73,7 @@ class ASTVisitor
   virtual void visit (AttrInputLiteral &attr_input) = 0;
   virtual void visit (AttrInputMacro &attr_input) = 0;
   virtual void visit (MetaItemLitExpr &meta_item) = 0;
-  virtual void visit (MetaItemPathLit &meta_item) = 0;
+  virtual void visit (MetaItemPathExpr &meta_item) = 0;
   virtual void visit (BorrowExpr &expr) = 0;
   virtual void visit (DereferenceExpr &expr) = 0;
   virtual void visit (ErrorPropagationExpr &expr) = 0;
@@ -240,6 +240,7 @@ class ASTVisitor
 
   // special AST nodes for certain builtin macros such as `asm!()`
   virtual void visit (FormatArgs &fmt) = 0;
+  virtual void visit (FormatArgsEager &fmt) = 0;
   virtual void visit (OffsetOf &fmt) = 0;
 
   // TODO: rust-cond-compilation.h visiting? not currently used
@@ -270,7 +271,7 @@ class DefaultASTVisitor : public ASTVisitor
   virtual void visit (AST::AttrInputLiteral &attr_input) override;
   virtual void visit (AST::AttrInputMacro &attr_input) override;
   virtual void visit (AST::MetaItemLitExpr &meta_item) override;
-  virtual void visit (AST::MetaItemPathLit &meta_item) override;
+  virtual void visit (AST::MetaItemPathExpr &meta_item) override;
   virtual void visit (AST::BorrowExpr &expr) override;
   virtual void visit (AST::DereferenceExpr &expr) override;
   virtual void visit (AST::ErrorPropagationExpr &expr) override;
@@ -413,6 +414,7 @@ class DefaultASTVisitor : public ASTVisitor
   virtual void visit (AST::FunctionParam &param) override;
   virtual void visit (AST::VariadicParam &param) override;
   virtual void visit (AST::FormatArgs &fmt) override;
+  virtual void visit (AST::FormatArgsEager &fmt) override;
   virtual void visit (AST::OffsetOf &fmt) override;
 
   template <typename T> void visit (T &node) { node.accept_vis (*this); }