December 2023 Monthly report

Overview

Thanks again to Open Source Security, inc and Embecosm for their ongoing support for this project.

Milestone Progress

All of the required “common part” patches were reviewed this month and subsequently pushed to GCC’s trunk branch. This allows us to move forward with updating upstream with the latest changes of our development repository. The commits are currently being tested once again one last time before a final push, which should happen this week. We will then resume work on the final parts of name resolution and handling of format_args!(), in order to support the required features for the GCC 14.1. release.

Progress on the compiler itself slowed down this month due to holidays. Both issues we had mentioned in our “Call for Contribution” section last month are being worked on, which is great. Thanks a lot for the interest in our project.

Jakub’s work on the borrow checker is continuing, with even more facts being emitted correctly and more invalid code being caught:

fn invalid_move() {
    // note that `A` is not `Copy`
    struct A {
        i: i32,
    }

    let a = A { i: 1 };
    let b = a; // a is moved here for the first time
    let c = a; //~ ERROR `a` moved here for the second time
}

fn valid_move() {
    let a = 1; // integers are `Copy`, so this is allowed
    let b = a;
    let c = a;
}

// runtime condition invalid move
fn test_move_conditional(b1: bool, b2:bool) {
    struct A {
        i: i32
    }

    let a = A { i: 1 }; // `A` cannot be copied

    if b1 {
        let b = a; // `a` might be moved here for the first time
    }
    if b2 {
        let c = a; // `a` might be moved here for the second time
    }
}

The work done by Jakub is also starting to enforce proper lifetime bounds:

fn lifetime_return_invalid<'a, 'b>(x: &'a u32, y: &'b u32) -> &'a u32 {
    y //~ ERROR 
}

fn lifetime_return_valid<'a, 'b>(x: &'a u32, y: &'b u32) -> &'a u32
    where 'b: 'a
{
    y
}

And can handle complex expressions and borrow situations:

struct Reference<'a> {
    value: &'a i32,
}

impl<'a> Reference<'a> {
    fn new<'a>(value: &'a i32) -> Reference<'a> {
        Reference { value }
    }
}

fn mutable_borrow_while_immutable_borrowed_struct() {
    let x = 0;
    let y = Reference::new(&x);
    let z = &mut x; //~ ERROR
    let w = y;
}

We are looking forward to more progress on this side of the compiler, as it is an extremely important part of the Rust programming language - it is absolutely necessary that a borrow checker exists for Linux developers to start working in Rust using gccrs. Note that Jakub is currently finishing studying for his Master’s Degree and is looking for sponsorship to continue his work on the borrow checker. Please get in touch if you or your company would be interested in funding his work!

Finally, Pierre-Emmanuel, Philip and Arthur will all be present at FOSDEM 2024. We are excited to meet everyone in both the Rust and GCC rooms.

Community call

We will not have our monthly community call this month as we are preoccupied with upstreaming patches. You can subscribe to our calendar to see when the next one will be held. The call is open to everyone, even if you would just like to sit-in and listen. You can also subscribe to our mailing-list or join our Zulip chat to be notified of upcoming events.

• Calendar ID: 7060a0923ffebd3cb52b1afef35a28ff7b64f05962c9af84c23b1847f1f5f894@group.calendar.google.com
• Google calendar link
• iCal link

Call for contribution

This is a new section for particularly easy or interesting issues we would like folks external to the project to contribute to. We are available for mentoring and guiding you on their resolution. This is a great way to start making your mark on a complex project such as this one and to learn a lot in the process!

• No fields in initializer - Internal Compiler Error Issue 2389

When an instance of a struct is created with missing fields, the compiler should error out and report an error - indicating which fields are missing (https://doc.rust-lang.org/error_codes/E0063.html). This is currently unimplemented in gccrs, and working on this issue will enable you to look at multiple parts of the compiler such as error reporting and typechecking.

• Missing type error on function pointers with different ABIs Issue 2034

gccrs should produce an error when passing a function pointer argument with a different ABI than the one expected. It is a simple check to add into our typechecker, as we already encode all necessary ABI information in our HIR.

Check out our Contributing guidelines to get started on them or feel free to send us a message on Zulip or IRC!

Completed Activities

• Refactor mangler PR2781
• Handle `async` qualifier inside trait PR2779
• TyTy: Remove deprecated FnDef API PR2776
• Renamed `WIN64` to `WIN<sub>64</sub>` PR2774
• Allow enabling ```lang<sub>items</sub>``` and ```no<sub>core</sub>``` features PR2773
• Borrowck ast lifetimes PR2771
• Minor changes needed for borrowck PR2770
• Make default resolver inherit from default visitor PR2763
• Make expand visitor inherit from default visitor PR2761
• Change cfg stripper to use default visitor PR2758
• Make function body optional and reject invalid functions during AST validation PR2755
• Generate error for const trait functions PR2754
• Respin the builtin PR PR2693
• Handle newlines during string parsing while lexing PR2684

Contributors this month

• Kushal Pal (new contributor!)
• Nobel Singh
• Nirmal Patel
• Jakub Dupak
• Marc Poulhiès
• Owen Avery
• Raiki Tamura

Overall Task Status

Test Cases

Bugs

Milestones Progress

Testing project

Planned Activities

• Opaque types
• Drop marker trait

Risks

Detailed changelog