Merge branch 'Rust-GCC:master' into master

Merge #811

811: Remove implicit name hack for trait associated types r=philberty a=philberty

There is still another hack I am working through to remove before fixing the issue.

Addresses: #739

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Remove implicit name hack for trait associated types

Before the TypePath resolution was updated to support associated type paths
and projections, we used an implict name hack of Self::<associated-type> as
well as the usual TraitName::<associates-type> this was a hack in the short
term to get things working which can now be removed.

Addresses: #739

Merge #810

810: Fix MethodCalls for covariant impl blocks r=philberty a=philberty

I think we need to research more into how we probe for potential candidates
for method calls. This fixes a few bugs going on in #808 one where the
canonical path was empty and one where we fail to probe directly on the
receiver of reference types to impl blocks but we must be able to also support
that autoderef means that a receiver's root type might actually be the type we
care about for example a reference to a generic type-parameter and we probe
its bounds for candidates for example. Lets consult the rustc code and references on this.

Fixes #808

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Merge #805

805: Remove Btype, Bexpression, etc. abstractions over gcc trees r=CohenArthur a=dafaust

As discussed in #412, the Rust front end inherits an abstraction over gcc from the initial bootstrap via GCCGO.
This is a cool idea, but adds overhead for the primary goal of gcc compiling Rust. It's not clear that the benefits of maintaining the abstraction are worth the potential extra headaches of maintaining it.

I figured for the sake of discussion, I'd draft an initial step towards removing this abstraction.

The implementations of classes `Bytpe`, `Bexpression`, `Bstatement`, `Bfunction`, and `Bblock` are only wrappers around gcc's GENERIC `tree` structure, with no added functionality. This PR removes them, and changes all the functions for creating and manipulating these abstract types to just use/return `tree` instead. I also deleted a few functions that are vestiges from GCCGO port and aren't used.

Personally, I think the abstraction should be removed in favor of using `tree`s. This is more in line with the other gcc front ends and makes the interface between the frontend and the rest of gcc simpler.

I'm curious to hear other opinions on the matter :)

Addresses: #412

Co-authored-by: David Faust <david.faust@oracle.com>

Probe for candidates on based on the actual receiver type

Impl blocks Self type is a TypeNoBouns which means it can be for types
such as: impl<T> &T {}.

I think we might need to change the probe algorithm for method calls to be
fully based on the autoderef rather than trying to filter based on the Self
type. More investigation is needed for the probe phase here.

Fixes #808

Add missing implict monomorphized types into the context

Unify the adjusted self argument to the self parameter on MethodCalls

When we must infer the substitutions on method calls we must make sure to
unify the self arguments from the receiver, taking into account the
autoderef mechanism. This enforces the type checks and fixes up any
inference variables along the way.

Addresses #808

Generic segments must be appended to the prefix and not override

Fix ICE assertion on bad duplicate name

This fixes the ice for TypeNoBounds canonical paths for reference types
which was not implemented resulting in empty paths for the canonical
path of impl_blocks for example.

A Fixme has been added to point out that we should update this interface
to only take AST::TypeNoBounds.

Fixes #808

clang-format and minor cleanup

Replace Blabel with GCC tree

Replace Bblock with GCC tree

Replace Bfunction with GCC tree

Replace Bstatement with GCC tree

Replace Bexpression with GCC tree

Replace Btype use with GCC tree

rust-backend.h: remove unused function prototypes

These functions are holdovers from the original port from the Go
frontend for Rust. They aren't used anywhere, so delete them from
rust-backend.h and rust-gcc.cc.

(set_)placeholder_xxx_type ()
(is_)circular_pointer_type ()

Merge #801

801: operator overloading r=philberty a=philberty

This change adds operator overloading by following how the C++ front-end
does it. We are relying on GCC to inline the operator overloads which does
occur once optimizations are enabled. It also brings back the desurgared
compound assignment expression (e2b761b13e6ccd3a7af4100183bb13e32b5b0da0)
for lang_items such as add_assign. You can find more information on how the algorithm works in:

- c47d5cbdee9b701fb7753b44530fcb51f80b20fa
- a7fb60bb626f7b936bf117636db777a5f0df30c9

These were refactored in: 0f74fe23c6d602c257ba94b2522bd9d6a594609e

Fixes #249

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

LazyBooleanExpr does not need a nullptr check

Add negation operator overload support

Unary operator expressions can be treated as simply having a nullptr
rvalue. This patch updates the shared operator overloading code to allow
for a nullptr rhs to canonicalize the code path for all operator overloads.

Fixes #249

Refactor operator overloading work to be more reuseable

Add support compound assignment operator overloads

Fixes #249

Revert desugaring of CompoundAssignment into arithmetic operation and assignment

Fixup verify assigneee to be permissive of PathInExpression

Initial support operator overloading on [lang = "add"]

This change incorporates a few changes.

1. Create new gcc/rust/backend/rust-compile-expr.cc to split out
   implementation code
2. Create new type check context api calls:
   - TypeCheckContext::lookup_operator_overload
   - TypeCheckContext::insert_operator_overload
3. Update type checking for ArithmeticOrLogicalExpr to look for any
   operator overloading

When we are looking for operator overloads we must look up the associated
lang item type for this paticular operation, to resolve the operation to
any known lang_items by looking up the specified lang_item to DefId. Then
we must probe for the lang_item candidate for this paticular lang_item
DefID to see if we can resolve it to a method call. Then based on the
autoderef rules in a MethodCallExpr we must verify that we don't end up
in a recursive operator overload by checking that the current context
is not the same as the actual operator overload for this type. Finally
we mark this expression as operator overload and setup everything as a
resolved MethodCallExpr.

Fixes #249

Update path probe with optional filter for specific associated trait

Sometimes when we probe for associated items we need to limit it to
items which are directly associated with a trait. This adds an optional
parameter to achieve this.

Support parsing LangItems on traits

Lang items are attributes that mark traits for specific behaviour with
compiler support kind of like builtin's/intrinsics.

This change adds parsing support for some of the arithmetic operator
overloads. The string names always correspond to the trait-item function
name too.

Add new TypeCheckContextItem to track current context

FIXME

Traits do allow TypeParameters with defaults

Core traits such as the arithmetic operations have generic arguments such
as: pub trait Add<Rhs = Self>

Addresses #249

Update AttrInput with AttrInputType

This allows us to switch based on the type which can be used for more complex usage of attributes such as lang_item parsing.

Addresses #742

Remove useless comments from HIR::MethodCallExpr

Merge #803

803: Partially disable clang-format in rust-diagnostics.h r=dkm a=dkm

clang-format is confused by attribute macros and does a very bad job at
indenting the code.

Changes merged in #779 make all clang-format checks to fail.

Signed-off-by: Marc Poulhiès <dkm@kataplop.net>
Co-authored-by: Marc Poulhiès <dkm@kataplop.net>

Merge #802

802: More help on running clang-format locally r=philberty a=dkm

Add note on using git-clang-format and clang-format-diff.py.

Remove the `clang-format` from the required items of PR as it's not enforced
anymore. It's now handled by regular code review.

Refs #242

Signed-off-by: Marc Poulhiès <dkm@kataplop.net>
Co-authored-by: Marc Poulhiès <dkm@kataplop.net>

Partially disable clang-format in rust-diagnostics.h

clang-format is confused by attribute macros and does a very bad job at
indenting the code.

Changes merged in #779 make all clang-format checks to fail.

Signed-off-by: Marc Poulhiès <dkm@kataplop.net>

Update CONTRIBUTING.md

Split sentence.

Co-authored-by: CohenArthur <arthur.cohen@epita.fr>

More help on running clang-format locally

Add note on using git-clang-format and clang-format-diff.py.

Remove the `clang-format` from the required items of PR as it's not enforced
anymore. It's now handled by regular code review.

Refs #242

Signed-off-by: Marc Poulhiès <dkm@kataplop.net>

Merge pull request #792 from npate012/defid_to_struct

Change DefId type from uint64_t to be struct

Changed DefId type from uint64_t to be struct

DefId was uint64_t previously but it has been changed to be a struct.
In order to reduce code breakage, ==, !=, and < operators have been implemented
for DefId. Since DefId is now a proper struct, bit manipulation code has been
removed with member accesses.

Fixes #439

Signed-off-by: Nirmal Patel <npate012@gmail.com>

Merge #798

798: Add missing const folding r=philberty a=philberty

Add some more missing constant-folding operations

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Merge #795

795: Running `clang-format` locally [#242] r=philberty a=tschwinge

Apparently everyone but me knows how to do that; I'm now documenting it for my
own future use.

Co-authored-by: Thomas Schwinge <thomas@codesourcery.com>

Added Remark.yml and .remarkrc

Addresses #487
Remark.yml contains the workflow and .remarkrc is the linter's config file.
Signed-off-by: M V V S Manoj Kumar <mvvsmanojkumar@gmail.com>

Merge #796

796: Handle forward declared items within blocks r=philberty a=philberty

This changes the resolution in BlockExpr's to iterate the Items then Stmts
but we might want to handle this by desugaring the HIR BlockExpr to have
items then stmts to ensure we type resolve the items before the stmts.

Fixes #531

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Remove clang-format from bors

Tag 'rust_fatal_error' as 'noreturn'

... like GCC's underlying 'fatal_error'.

By definition, we cannot continue, upon having run into a fatal error.

Turn 'rust_error_at' plus always-failing 'rust_assert' into 'rust_internal_error_at'

These three were added in commit cbfc0ee239fafc0dadaae314138410f9119c65fa
"This allows for query based compilation", part of
<https://github.com/Rust-GCC/gccrs/pull/640> "Optional Trait items constants".

Given:

    if ([...]
        && [X])
      {
        rust_error_at ([...]);
        rust_assert (![X]);
      }

..., this means that the 'rust_assert' always fires, so this is a condition
that is not meant to happen (also, there are no test cases triggering this),
so use 'rust_internal_error_at' instead.

Add 'rust_internal_error_at'

... corresponding to GCC's 'internal_error'.

Add missing const-folding for (expr)

Const fold ref,pointer,borrow+deref

Support forward declared items within blocks

This changes the BlockExpr resolution to iterate Items first, then the
Stmts. This could be handled in HIR by desugaring the BlockExpr by lowering
the block into { <items>; <stmts>; } would also work. But the HIR lowering
of blocks is a little messy right now and we need to clean up the
unreachable lint.

Fixes #531

Add is_item helper to AST and HIR

BlockExpr can contain Items and Stmts this allows us to differentiate
between them on the Stmt level.

Merge #794

794: Fix unhandled type bounds in TypeAlias r=philberty a=philberty

This adds support for trait-object-types and desugars HIR::TraitObjectTypeOneBound into a single
HIR::TraitObjectType. This also adds the missing cases of the generic arguments to the TypeBoundPredicates.

It also contains cleanup for helpers used during monomorphization and a recursion limiter which is likely set too
low but it is good enough for the test-cases we have now to get good back-traces.

Fixes #786

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Support computing the addresses of the object safe items in dyn objects

This changes the coercion code for the dyn vtable to compute addresses
for more complex generic methods such as:

```
impl<'a, T> FnLike<&'a T, &'a T> for Identity {
    fn call(&self, arg: &'a T) -> &'a T {
        arg
    }
}
```

In the above example the fntype for the bound FnLike is generic and
bound to the ParamType 'T' from the generic impl-block. But the bound
which has a signiture which is compatible for the impl block looks like:

```
trait FnLike<A, R> {
    fn call(&self, arg: A) -> R;
}
```

This means when we have the trait-object bound:

```
type FnObject<'b> = dyn for<'a> FnLike<&'a isize, &'a isize> + 'b
```

We must be able to figure out that the signiture of the impl block item

```
fn call(&self, arg: &'a T) -> &'a T;
```

T must be substituted with &isize from the arguments used in the bound.

Fixes #786

Running `clang-format` locally [#242]

Apparently everyone but me knows how to do that; I'm now documenting it for my
own future use.

Enforce the is_concrete inferface to start cleaning up the needs_substitution helpers

Add missing generic arguments to type-bound-predicate on trait-objects

Add generic-arguments to predicate as_string

Remove duplicate accessors which can be const

When we are resolving TypePaths default the result to ErrorType

Fix nullptr as the result is not setup in this case

Make self const when compiling trait-items

Add a recursion-limit when resolving Parameter Types

This limit is likely way too low but its ok for now to get decent
backtraces for the test-cases we are working with right now.

Add missing bound to impl-type Self

Add ImplItemTypes enum to switch between HIR::ImplItem types

Merge #785

785: rust: track inline module scopes for module file resolution r=CohenArthur a=mathstuf

The set of inline modules is required to find the expected location of a
module file. Track this information with an RAII object
(`InlineModuleStackScope`) and pass it down to any out-of-line modules
so that, when requested, the set of inline modules can be added to the
search path.

Signed-off-by: Ben Boeckel <mathstuf@gmail.com>
---
Note that this does not include a test case because I have no idea how to mark up this for all the warnings that come out (#676):

```diff
diff --git a/gcc/testsuite/rust/compile/missing_middle/sub/mod.rs b/gcc/testsuite/rust/compile/missing_middle/sub/mod.rs
new file mode 100644
index 00000000000..f099d61e04a
--- /dev/null
+++ b/gcc/testsuite/rust/compile/missing_middle/sub/mod.rs
`@@` -0,0 +1,3 `@@`
+pub fn f() -> u32 {
+    1
+}
diff --git a/gcc/testsuite/rust/compile/mod_missing_middle.rs b/gcc/testsuite/rust/compile/mod_missing_middle.rs
new file mode 100644
index 00000000000..d9cdf0a54f1
--- /dev/null
+++ b/gcc/testsuite/rust/compile/mod_missing_middle.rs
`@@` -0,0 +1,11 `@@`
+pub mod missing_middle {
+    pub mod sub;
+}
```

Observed warnings:

```
/home/boeckb/code/depot/group-compilers/gcc/src-gccrs/gcc/testsuite/rust/compile/missing_middle/sub/mod.rs:1:5: warning: unused name 'f'
/home/boeckb/code/depot/group-compilers/gcc/src-gccrs/gcc/testsuite/rust/compile/mod_missing_middle.rs:2:9: warning: unused name 'sub'
/home/boeckb/code/depot/group-compilers/gcc/src-gccrs/gcc/testsuite/rust/compile/missing_middle/sub/mod.rs:1:5: warning: unused name 'sub::f'
/home/boeckb/code/depot/group-compilers/gcc/src-gccrs/gcc/testsuite/rust/compile/mod_missing_middle.rs:2:9: warning: unused name 'missing_middle::sub'
/home/boeckb/code/depot/group-compilers/gcc/src-gccrs/gcc/testsuite/rust/compile/mod_missing_middle.rs:1:5: warning: unused name 'missing_middle'
/home/boeckb/code/depot/group-compilers/gcc/src-gccrs/gcc/testsuite/rust/compile/missing_middle/sub/mod.rs:1:5: warning: unused name 'missing_middle::sub::f'
```

Fixes: #645
Here is a checklist to help you with your PR.

- \[x] GCC development requires copyright assignment or the Developer's Certificate of Origin sign-off, see https://gcc.gnu.org/contribute.html or https://gcc.gnu.org/dco.html
- \[x] Read contributing guidlines
- \[x] `make check-rust` passes locally
- \[x] Run `clang-format` (leaving to CI)
- \[x] Added any relevant test cases to `gcc/testsuite/rust/` (see above)

Co-authored-by: Ben Boeckel <mathstuf@gmail.com>

Merge #791

791: Replace TyTy::TupleType::iterate_fields with a new function get_fields r=philberty a=cls

This PR replaces TyTy::TupleType::iterate_fields with a new function get_fields.

In #735, `@philberty` mentions two possible implementations of get_fields, one that returns `std::vector<TyVar>&` and one that returns a new `std::vector<BaseType *>`. I've included two commits, the first doing the former and second going on to do the latter. I'm happy with one or both being merged.

This is my first PR, so please let me know if I've missed anything! Thanks.

Fixes #735

Co-authored-by: Connor Lane Smith <cls@lubutu.com>

Replace TupleType::iterate_fields with get_fields

Fixes #735

Signed-off-by: Connor Lane Smith <cls@lubutu.com>

Desugar AST::TraitObjectTypeOneBound

We have two ways to represent TraitObjectType's:

- AST::TraitObjectType
- AST::TraitObjectTypeOneBound

This desugars this within HIR into a single HIR::TraitObjectType which
contains a list of bounds.

Addresses #786

rust: track inline module scopes for module file resolution

The set of inline modules is required to find the expected location of a
module file. Track this information with an RAII object
(`InlineModuleStackScope`) and pass it down to any out-of-line modules
so that, when requested, the set of inline modules can be added to the
search path.

Signed-off-by: Ben Boeckel <mathstuf@gmail.com>

Merge #781

781: Add missing typechecking for enums r=philberty a=philberty

This PR splits up the Algebraic data type into one which can support many variants which is what an enum is.
It then changes the type checking for construction of ADT's to use the VariantDef structures as required. This
does not fully implement but does allow us to have most of the type checking in place to start code-generation work.

This combines work from Mark Wielaard (https://code.wildebeest.org/git/user/mjw/gccrs/commit/?h=enum-type) and Philip

Addresses #79

Co-authored-by: Mark Wielaard <mark@klomp.org>
Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Merge #788

788: gccrs: add the `-frust-crate=` option to set the crate name r=philberty a=mathstuf

Signed-off-by: Ben Boeckel <mathstuf@gmail.com>
Fixes: #627
Co-authored-by: Ben Boeckel <mathstuf@gmail.com>

Default type checking on CallExpr's to TyTy::ErrorType

It is ok for type checking to error/fail on a construct within the crate,
we can try our best to continue on to find as many errors as possible. To
achieve this without running into nullptr's we can use the ErrorType node
to signify an error. This also cleans up alot of noise in our error
handling.

Support Typechecking of ADT's of enums

Enums are ADT's with multiple variants where as structs are ADT's with a
single variant, this changes the typechecking on construction of these to
support enums.

Addresses #79

gccrs: add the `-frust-crate=` option to set the crate name

Signed-off-by: Ben Boeckel <mathstuf@gmail.com>

Refactor struct-expr typechecking into its own impl file

Merge #787

787: gha: save `check-rust` results as artifacts r=philberty a=mathstuf

They will stick around for 90 days (as per GitHub default limits).

     https://docs.github.com/en/actions/advanced-guides/storing-workflow-data-as-artifacts

Signed-off-by: Ben Boeckel <mathstuf@gmail.com>
Fixes: #634
Co-authored-by: Ben Boeckel <mathstuf@gmail.com>

gha: save `check-rust` results as artifacts

They will stick around for 90 days (as per GitHub default limits).

     https://docs.github.com/en/actions/advanced-guides/storing-workflow-data-as-artifacts

Signed-off-by: Ben Boeckel <mathstuf@gmail.com>

Add missing ID to variant ids

Add TypePath resolution for enum ctor

When constructing enums we end up with a path like Enum::discriminant so
we must lookup the variant to figure out how to construct the enum.

Addresses #79

Get rid of bad gcc_unreachable

Add type-resolution for enum items

This patch does the type resolution to actually create the types when we
encounter enums within toplevel HIR::Items and HIR::Stmt conext's.

We don't support actual creation of enums yet in this patch but this is
an isolated building block.

Co-authored-by: Philip Herron <philip.herron@embecosm.com>
Addresses #79

Refactor ADTType to consist of multiple variants

Algebraic data types represent Structs, Tuple Structs, unit
structs and enums in rust. The key difference here is that
each of these are an ADT with a single variant and enums
are an ADT with multiple variants.

It adds indirection to where the fields of an ADT are
managed.

Co-authored-by: Mark Wielaard <mark@klomp.org>
Addresses #79

Extract reuseable function to handle substitutions for struct fields

Get rid of lambda get_fields in struct

Add missing accessors for enum items

Merge #783

783: Get rid of lambda within `AST::TypePath` and provide a method to return a reference r=philberty a=diohabara

## Related issue

This PR will fix <https://github.com/Rust-GCC/gccrs/issues/718>

- \[x] GCC development requires copyright assignment or the Developer's Certificate of Origin sign-off, see https://gcc.gnu.org/contribute.html or https://gcc.gnu.org/dco.html
- \[x] Read contributing guidlines
- \[x] `make check-rust` passes locally
- \[x] Run `clang-format`
- \[x] Added any relevant test cases to `gcc/testsuite/rust/`

Note that you can skip the above if you are just opening a WIP PR in
order to get feedback.

Co-authored-by: Kadoi Takemaru <diohabara@gmail.com>

Get rid of lambda within AST::TypePath and provide a method to return a reference

Remove lambda expressions within AST::TypePath and use get_segments() to
iterate over AST::TypePathSegment

Fixes #718

Signed-off-by: Kadoi Takemaru <diohabara@gmail.com>

Merge #780

780: No side effects in 'assert' expressions r=philberty a=tschwinge

Usually, if 'assert'ions are disabled, 'assert' expressions are not evaluated,
so in that case won't effect any side effects.

Via spurious ICEs/test suite FAILs, this may be observed in GCC/Rust, for
example, if configuring with '--enable-checking=no' and disabling a "more
forgiving" 'gcc/system.h:gcc_assert' definition, so that '0 && (EXPR)' gets
used:

     /* Use gcc_assert(EXPR) to test invariants.  */
     #if ENABLE_ASSERT_CHECKING
     #define gcc_assert(EXPR)                                               \
        ((void)(!(EXPR) ? fancy_abort (__FILE__, __LINE__, __FUNCTION__), 0 : 0))
    -#elif (GCC_VERSION >= 4005)
    +#elif (0) //GCC_VERSION >= 4005)
     #define gcc_assert(EXPR)                                               \
       ((void)(__builtin_expect (!(EXPR), 0) ? __builtin_unreachable (), 0 : 0))
     #else
     /* Include EXPR, so that unused variable warnings do not occur.  */
     #define gcc_assert(EXPR) ((void)(0 && (EXPR)))
     #endif

As that one does cause some issues in GCC proper (that I shall fix separately),
may use this change to 'gcc/rust/rust-system.h:rust_assert' instead:

    +#if 0
     #define rust_assert(EXPR) gcc_assert (EXPR)
    +#else
    +#define rust_assert(EXPR) ((void) (0 && (EXPR)))
    +#endif

To fix these, use the same pattern as is already used in a lot of existing
GCC/Rust code:

    bool ok = [expression with side effects];
    rust_assert (ok);

I've only done a quick manual review; maybe there is a tool for doing this?

Co-authored-by: Thomas Schwinge <thomas@codesourcery.com>

Merge #778

778: Add location info in AST::TypeBoundWhereClauseItem and HIR::TypeBoundWhereClauseItem r=philberty a=npate012

Location info has been added to AST::TypeBoundWhereClauseItem and HIR::TypeBoundWhereClauseItem. parse_type_bound_where_clause_item () has been modified to fetch location info and store it in AST::TypeBoundWhereClauseItem.

Fixes #766

Signed-off-by: Nirmal Patel <npate012@gmail.com>
Co-authored-by: Nirmal Patel <npate012@gmail.com>

No side effects in 'assert' expressions

Usually, if 'assert'ions are disabled, 'assert' expressions are not evaluated,
so in that case won't effect any side effects.

Via spurious ICEs/test suite FAILs, this may be observed in GCC/Rust, for
example, if configuring with '--enable-checking=no' and disabling a "more
forgiving" 'gcc/system.h:gcc_assert' definition, so that '0 && (EXPR)' gets
used:

     /* Use gcc_assert(EXPR) to test invariants.  */
     #if ENABLE_ASSERT_CHECKING
     #define gcc_assert(EXPR)                                               \
        ((void)(!(EXPR) ? fancy_abort (__FILE__, __LINE__, __FUNCTION__), 0 : 0))
    -#elif (GCC_VERSION >= 4005)
    +#elif (0) //GCC_VERSION >= 4005)
     #define gcc_assert(EXPR)                                               \
       ((void)(__builtin_expect (!(EXPR), 0) ? __builtin_unreachable (), 0 : 0))
     #else
     /* Include EXPR, so that unused variable warnings do not occur.  */
     #define gcc_assert(EXPR) ((void)(0 && (EXPR)))
     #endif

As that one does cause some issues in GCC proper (that I shall fix separately),
may use this change to 'gcc/rust/rust-system.h:rust_assert' instead:

    +#if 0
     #define rust_assert(EXPR) gcc_assert (EXPR)
    +#else
    +#define rust_assert(EXPR) ((void) (0 && (EXPR)))
    +#endif

To fix these, use the same pattern as is already used in a lot of existing
GCC/Rust code:

    bool ok = [expression with side effects];
    rust_assert (ok);

I've only done a quick manual review; maybe there is a tool for doing this?

Add location info in AST::TypeBoundWhereClauseItem and HIR::TypeBoundWhereClauseItem

Location info has been added to AST::TypeBoundWhereClauseItem and
HIR::TypeBoundWhereClauseItem. parse_type_bound_where_clause_item () has been
modified to fetch location info and store it in AST::TypeBoundWhereClauseItem

Fixes #766

Signed-off-by: Nirmal Patel <npate012@gmail.com>

Merge #774

774: Removed lambda in iterate_params within CallExpr and MethodCallExpr r=tschwinge a=npate012

Signed-off-by: Nirmal Patel <npate012@gmail.com>
Removed iterate_params from AST::CallExpr and AST::MethodCallExpr.

Fixes #722 #723

Co-authored-by: Nirmal Patel <npate012@gmail.com>

Remove iterate_params from AST::CallExpr and AST::MethodCallExpr

These lambda iterators are removed because they make working
with IR more complex. Instead, we are using the get_params ()
to access the parameters with the help of a for loop.

Fixes #722 #723

Signed-off-by: Nirmal Patel <npate012@gmail.com>

Merge #775

775: Support const within block-expr's r=philberty a=philberty

This adds support for constant folding within block expr's and constant
ArrayIndexExpression.

Fixes #711

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Add constant folding to ArrayIndexExpr

This ensures that constexpr is enforced for array-index-exprs resulting in
gimple like this:

```rust
fn main() {
    const A: [i32; 3] = [1, 2, 3];
    const B: i32 = A[1];
    const C: usize = 42;
    const D: i32 = 7;

    let _a = C;
    let _b: [i32; C] = [0; C];
    let _c = B + D;
}
```

```c
void main ()
{
  const usize _a;
  i32 _b[42];
  const i32 _c;

  try
    {
      _a = 42;
      _b = {};
      _1 = 2;
      _c = _1 + 7;
    }
  finally
    {
      _b = {CLOBBER};
    }
}
```

Add support for constants within blocks

BlockExpr's can contain constants these are Items which can exist within
the BlockExpr Stmt list. Items like structs, functions and constants all
inherit from Item so there is some duplication of code but we still
do not support the forward declared Items within a stmt list so the
duplication will need to be fixed as part of that bug.

Fixes #711

Merge #771

771: Add higher ranked trait bounds r=philberty a=philberty

This adds support for where clauses and higher ranked trait bounds more test cases are needed
since where clauses are supported on associated types, impls, ADT's etc. See the individual
commits for more detail on implementation.

Fixes #773 #442

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

Fix parser error for lifetime arguments

The loop was eagerly trying to ensure that there was multiple lifetimes
since the predicate assumed there will be a comma or delimiter for the
arguments. This changes the loop to keep reading lifetimes untill we fail to parse a lifetime or hit the end of the arguments.

Fixes #773

Add support for higher ranked trait bounds

This adds the type checking for the bounds which will add the relevant
bounds to the associated types and perform the relevant type checking
required.

Fixes #442

TyTy add bounds in debug string