Ci improvements

.github/workflows/ccpp.yml

@@ -9,12 +9,17 @@ on:
     branches: [ master ]
   merge_group:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build-and-check-ubuntu-64bit:
 
     env:
       # Force locale, in particular for reproducible results re '.github/bors_log_expected_warnings' (see below).
       LC_ALL: C.UTF-8
+      SCCACHE_GHA_ENABLED: "true"
 
     runs-on: ubuntu-22.04
 
@@ -39,11 +44,14 @@ jobs:
                   g++-multilib \
                   dejagnu
 
+    - name: Run sccache-cache
+      uses: mozilla-actions/[email protected]
+
     - name: Configure
       run: |
            mkdir -p gccrs-build;
            cd gccrs-build;
-           ../configure \
+           ../configure CC="sccache gcc" CXX="sccache g++" \
                --enable-languages=rust \
                --disable-bootstrap \
                --enable-multilib
@@ -54,6 +62,10 @@ jobs:
            cd gccrs-build; \
            make -Otarget -j $(nproc) 2>&1 | tee log
 
+    - name: Show sccache stats
+      shell: bash
+      run: ${SCCACHE_PATH} --show-stats
+
     - name: Check for new warnings
       run: |
            cd gccrs-build

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

@@ -85,8 +85,9 @@ std::unique_ptr<Expr>
 AstBuilder::block (std::vector<std::unique_ptr<Stmt>> &&stmts,
 		   std::unique_ptr<Expr> &&tail_expr)
 {
-  return std::unique_ptr<Expr> (
-    new BlockExpr (std::move (stmts), std::move (tail_expr), {}, {}, loc, loc));
+  return std::unique_ptr<Expr> (new BlockExpr (std::move (stmts),
+					       std::move (tail_expr), {}, {},
+					       LoopLabel::error (), loc, loc));
 }
 
 std::unique_ptr<Stmt>

gcc/rust/ast/rust-ast.h

@@ -1194,7 +1194,7 @@ class Pattern : public Visitable
   virtual bool is_marked_for_strip () const { return false; }
 
   virtual location_t get_locus () const = 0;
-  virtual NodeId get_pattern_node_id () const = 0;
+  virtual NodeId get_node_id () const = 0;
 
 protected:
   // Clone pattern implementation as pure virtual method
@@ -1446,82 +1446,81 @@ class LifetimeParam : public GenericParam
   }
 };
 
+class AssociatedItem : public Visitable
+{
+protected:
+  // Clone function implementation as pure virtual method
+  virtual AssociatedItem *clone_associated_item_impl () const = 0;
+
+public:
+  virtual ~AssociatedItem () {}
+
+  std::unique_ptr<AssociatedItem> clone_associated_item () const
+  {
+    return std::unique_ptr<AssociatedItem> (clone_associated_item_impl ());
+  }
+
+  virtual std::string as_string () const = 0;
+
+  virtual void mark_for_strip () = 0;
+  virtual bool is_marked_for_strip () const = 0;
+
+  virtual location_t get_locus () const = 0;
+};
+
 // Item used in trait declarations - abstract base class
-class TraitItem : public Visitable
+class TraitItem : virtual public AssociatedItem
 {
 protected:
   TraitItem (location_t locus)
     : node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
   {}
 
   // Clone function implementation as pure virtual method
-  virtual TraitItem *clone_trait_item_impl () const = 0;
+  virtual TraitItem *clone_associated_item_impl () const override = 0;
 
   NodeId node_id;
   location_t locus;
 
 public:
-  virtual ~TraitItem () {}
-
   // Unique pointer custom clone function
   std::unique_ptr<TraitItem> clone_trait_item () const
   {
-    return std::unique_ptr<TraitItem> (clone_trait_item_impl ());
+    return std::unique_ptr<TraitItem> (clone_associated_item_impl ());
   }
 
-  virtual std::string as_string () const = 0;
-
-  virtual void mark_for_strip () = 0;
-  virtual bool is_marked_for_strip () const = 0;
-
   NodeId get_node_id () const { return node_id; }
   location_t get_locus () const { return locus; }
 };
 
 /* Abstract base class for items used within an inherent impl block (the impl
  * name {} one) */
-class InherentImplItem : public Visitable
+class InherentImplItem : virtual public AssociatedItem
 {
 protected:
   // Clone function implementation as pure virtual method
-  virtual InherentImplItem *clone_inherent_impl_item_impl () const = 0;
+  virtual InherentImplItem *clone_associated_item_impl () const override = 0;
 
 public:
-  virtual ~InherentImplItem () {}
-
   // Unique pointer custom clone function
   std::unique_ptr<InherentImplItem> clone_inherent_impl_item () const
   {
-    return std::unique_ptr<InherentImplItem> (clone_inherent_impl_item_impl ());
+    return std::unique_ptr<InherentImplItem> (clone_associated_item_impl ());
   }
-
-  virtual std::string as_string () const = 0;
-
-  virtual void mark_for_strip () = 0;
-  virtual bool is_marked_for_strip () const = 0;
-
-  virtual location_t get_locus () const = 0;
 };
 
 // Abstract base class for items used in a trait impl
-class TraitImplItem : public Visitable
+class TraitImplItem : virtual public AssociatedItem
 {
 protected:
-  virtual TraitImplItem *clone_trait_impl_item_impl () const = 0;
+  virtual TraitImplItem *clone_associated_item_impl () const override = 0;
 
 public:
-  virtual ~TraitImplItem (){};
-
   // Unique pointer custom clone function
   std::unique_ptr<TraitImplItem> clone_trait_impl_item () const
   {
-    return std::unique_ptr<TraitImplItem> (clone_trait_impl_item_impl ());
+    return std::unique_ptr<TraitImplItem> (clone_associated_item_impl ());
   }
-
-  virtual std::string as_string () const = 0;
-
-  virtual void mark_for_strip () = 0;
-  virtual bool is_marked_for_strip () const = 0;
 };
 
 // Abstract base class for an item used inside an extern block

gcc/rust/ast/rust-expr.h

@@ -11,6 +11,36 @@ namespace AST {
  * "has_whatever" pairs with
  * optional types (std::optional or boost::optional)? */
 
+// Loop label expression AST node used with break and continue expressions
+// TODO: inline?
+class LoopLabel /*: public Node*/
+{
+  Lifetime label; // or type LIFETIME_OR_LABEL
+  location_t locus;
+
+  NodeId node_id;
+
+public:
+  std::string as_string () const;
+
+  LoopLabel (Lifetime loop_label, location_t locus = UNDEF_LOCATION)
+    : label (std::move (loop_label)), locus (locus),
+      node_id (Analysis::Mappings::get ()->get_next_node_id ())
+  {}
+
+  // Returns whether the LoopLabel is in an error state.
+  bool is_error () const { return label.is_error (); }
+
+  // Creates an error state LoopLabel.
+  static LoopLabel error () { return LoopLabel (Lifetime::error ()); }
+
+  location_t get_locus () const { return locus; }
+
+  Lifetime &get_lifetime () { return label; }
+
+  NodeId get_node_id () const { return node_id; }
+};
+
 // AST node for an expression with an accompanying block - abstract
 class ExprWithBlock : public Expr
 {
@@ -2396,6 +2426,7 @@ class BlockExpr : public ExprWithBlock
   std::vector<Attribute> inner_attrs;
   std::vector<std::unique_ptr<Stmt> > statements;
   std::unique_ptr<Expr> expr;
+  LoopLabel label;
   location_t start_locus;
   location_t end_locus;
   bool marked_for_strip = false;
@@ -2412,19 +2443,21 @@ class BlockExpr : public ExprWithBlock
   BlockExpr (std::vector<std::unique_ptr<Stmt> > block_statements,
 	     std::unique_ptr<Expr> block_expr,
 	     std::vector<Attribute> inner_attribs,
-	     std::vector<Attribute> outer_attribs, location_t start_locus,
-	     location_t end_locus)
+	     std::vector<Attribute> outer_attribs, LoopLabel label,
+	     location_t start_locus, location_t end_locus)
     : outer_attrs (std::move (outer_attribs)),
       inner_attrs (std::move (inner_attribs)),
       statements (std::move (block_statements)), expr (std::move (block_expr)),
-      start_locus (start_locus), end_locus (end_locus)
+      label (std::move (label)), start_locus (start_locus),
+      end_locus (end_locus)
   {}
 
   // Copy constructor with clone
   BlockExpr (BlockExpr const &other)
     : ExprWithBlock (other), outer_attrs (other.outer_attrs),
-      inner_attrs (other.inner_attrs), start_locus (other.start_locus),
-      end_locus (other.end_locus), marked_for_strip (other.marked_for_strip)
+      inner_attrs (other.inner_attrs), label (other.label),
+      start_locus (other.start_locus), end_locus (other.end_locus),
+      marked_for_strip (other.marked_for_strip)
   {
     // guard to protect from null pointer dereference
     if (other.expr != nullptr)
@@ -2524,6 +2557,9 @@ class BlockExpr : public ExprWithBlock
     outer_attrs = std::move (new_attrs);
   }
 
+  bool has_label () { return !label.is_error (); }
+  LoopLabel &get_label () { return label; }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
@@ -3352,36 +3388,6 @@ class UnsafeBlockExpr : public ExprWithBlock
   }
 };
 
-// Loop label expression AST node used with break and continue expressions
-// TODO: inline?
-class LoopLabel /*: public Node*/
-{
-  Lifetime label; // or type LIFETIME_OR_LABEL
-  location_t locus;
-
-  NodeId node_id;
-
-public:
-  std::string as_string () const;
-
-  LoopLabel (Lifetime loop_label, location_t locus = UNDEF_LOCATION)
-    : label (std::move (loop_label)), locus (locus),
-      node_id (Analysis::Mappings::get ()->get_next_node_id ())
-  {}
-
-  // Returns whether the LoopLabel is in an error state.
-  bool is_error () const { return label.is_error (); }
-
-  // Creates an error state LoopLabel.
-  static LoopLabel error () { return LoopLabel (Lifetime::error ()); }
-
-  location_t get_locus () const { return locus; }
-
-  Lifetime &get_lifetime () { return label; }
-
-  NodeId get_node_id () const { return node_id; }
-};
-
 // Base loop expression AST node - aka LoopExpr
 class BaseLoopExpr : public ExprWithBlock
 {