July 2023 Monthly report

Overview

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

Milestone Progress

A lot of progress was done in almost all areas of the compiler this month, with improvements being done on all stages of our pipeline: our GSoC student Raiki Tamura made some significant changes to the lexer and added multiple routines around unicode handling. Furthermore, they are bringing a Unicode Normalization generator to the compiler, allowing us to easily keep up to date with the latest Unicode standard. Mahad Muhammad, on the other hand, keeps dwelving into the guts of the compiler, looking for error codes to add and raising issues as they go. Both of these works are extremely useful as we get closer and closer to attempting to run the rustc testsuite. Both students had their mid-term evaluation this month, and passed it with flying colors. Congratulations both! And thank you for your continued work.

We are also getting a lot of contributions from Owen Avery, who has done an amazing job cleaning up some of the older, unecessary abstractions still present in the compiler. Marc Poulhiès merged his new HIR dump visitor, which is proving to be very helpful for debugging this stage of the compilation pipeline, which Philip is working on to get the last few bits of iterators working. Keeping on the HIR side of things, Jakub Dupak has started their work on facts generation for the polonius-engine library, which will help in bringing borrow-checking to the compiler. This work is extremely experimental, but they are making good progress and we are excited to see where it goes! On the other hand of the compiler, Arthur and Pierre-Emmanuel are working on the new name resolution algorithm, which is proving to be time-consuming but extremely rewarding. The new resolver code is simple and should be easy to maintain. We have completed the work necessary for macro name resolution, an important part of the “early” name resolution in Rust, and are now working to complete procedural macro resolution. At the same time, Philip and Arthur will start work on “late” name resolution, plugging together our new resolver and the existing typechecker where necessary. Once these last few steps will be completed, we should be in a very good position to succesfully compile Rust’s 1.49 core library.

In total, the work this month totaled 88 pull-requests merged. This is an extremely impressive number, and one of the highest we have had since the beginning of the project. The team is extremely thankful to all the contributors, and to all of the amazing people we get to interact with.

In other news, the GCC project has published a Code of Conduct, which the gccrs project adopted. If you remember, we were previously using the Rust Project’s Code of Conduct, which suited us nicely. During the last community meeting, we reviewed the new Code of Conduct and decided to switch to it, as it contains similar community requirements. We are also getting ready for conference season, during which we plan on giving two talks: one at the GNU Cauldron in Cambridge at the end of September, and one in Brussels for EuroRust in October. We hope to meet a lot of people once again!

Community call

We will have our next monthly community call on the 14th of August 2023. 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.

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

Completed Activities

• gccrs: Fix ICE by adding check for enum candidate’s PR2490
• Add missing ```CHECKING<sub>P</sub>``` guard to ```rust-unicode.cc``` PR2488
• gccrs: fix ice when function is outside of context PR2486
• Move ```Gcc<sub>backend</sub>``` declaration to header file PR2485
• gccrs: fix ICE when we have unimplemented/invalid trait items PR2484
• Start supporting ?Sized and Sized properly PR2483
• Remove ```Location``` typedef PR2482
• error codes: Add rust_errorcodes.def, refactor ErrorCode enum PR2480
• Proc macro literal from string PR2476
• Add `is<sub>available</sub>` function implementation PR2475
• Increase FFIString usage PR2472
• Proc macro non root level verification PR2471
• New Error Code Framework PR2468
• Proc macro non function errors PR2465
• Unicode check for crate_name attribute PR2463
• Prevent multiple bootstrap builds from running at once PR2462
• Remove NodeId from identifiers PR2457
• [E0571] break with argument in non-loop loop PR2455
• [E0268] break or continue used outside of loop PR2453
• [E0045] Variadic Parameters Used on Non-C ABI Function PR2451
• Change Ident structure PR2449
• Replace ```Location``` with ```location<sub>t</sub>``` in gccrs backend PR2448
• Replace default argument with ```UNDEF<sub>LOCATION</sub>``` PR2447
• Add privacy check to `proc<sub>macro</sub>`, `proc<sub>macroderive</sub>` and `proc<sub>macroattribute</sub>` attributes. PR2446
• [E0323] Implemented associated const, expected another trait PR2445
• Proc macro attribute check PR2444
• Replace ```Location``` with ```location<sub>t</sub>``` in parsing and macro expansion PR2441
• Replace ```Location``` with ```location<sub>t</sub>``` in unnamed function parameters PR2439
• Replace usages of ```Location``` with ```location<sub>t</sub>``` in typechecking PR2438
• cli: Add frust-type option PR2435
• [E0423] expected function, tuple struct or tuple variant, found struct PR2432
• Remove ```Linemap::predeclared<sub>location</sub>``` PR2429
• Move some ```Gcc<sub>backend</sub>``` method definitions out of class declaration PR2428
• Add include guard for ```rust-gcc.h``` PR2427
• Add header file generator for Unicode normalization and alphanumeric check PR2425
• [E0133] Use of unsafe code outside of unsafe function or block PR2424
• Replace usages of ```Location``` with ```location<sub>t</sub>``` in the lexer, AST, and HIR PR2420
• Continue to replace usages of ```Location``` with ```location<sub>t</sub>``` PR2419
• Replace more usages of ```Location``` with ```location<sub>t</sub>``` PR2418
• rust-unreachable: Add specific behavior for rust_unreachable PR2416
• gccrs: minor HIR cleanup PR2415
• mklog: handle Signed-Off-By, minor cleanup PR2414
• Replace some usages of ```Location``` with ```location<sub>t</sub>``` PR2413
• Fix several warnings PR2412
• proc_macro: Add from string implementation PR2409
• [E0658] Use of unstable feature PR2408
• [E0093] Declaration of unknown intrinsic function PR2407
• Remove unnecessary usage of ```Location``` copy constructor PR2406
• gccrs: minor HIR cleanup PR2405
• Remove ```RichLocation``` typedef PR2404
• Change class ```RichLocation``` into typedef PR2403
• Remove ```Linemap::start<sub>line</sub>``` PR2402
• Remove ```Linemap::get<sub>location</sub>``` PR2401
• Merge ```Linemap::to<sub>string</sub>``` into ```Linemap::location<sub>tostring</sub>``` PR2400
• dump: Output escaped character values PR2399
• [E0124] field `x` is already declared in struct PR2397
• Add ```rust<sub>errorat</sub>``` accepting ```location<sub>t</sub>``` and ```ErrorCode``` PR2395
• Merge ```Linemap``` and ```Gcc<sub>linemap</sub>``` PR2393
• Replace ```Linemap::unknown<sub>location</sub>``` with ```UNKNOWN<sub>LOCATION</sub>``` PR2392
• [E0070] invalid left-hand side of assignment PR2390
• [E0063] constructor is missing fields PR2387
• [E0425] Use of unresolved name PR2383
• [E0053] method ‘x’ has an incompatible type for trait ‘y’ PR2380
• [E0046] Missing Items in Trait Implementation PR2377
• Add utf-8 validation for input source PR2374
• [E0061] Refactored argument mismatch error function PR2373
• gccrs: HIR cleanup PR2372
• Reduce Linemap/Gcc_linemap abstraction further PR2371
• Reduce Linemap/Gcc_linemap abstraction PR2370
• [E0229] associated type bindings error PR2367
• [E0034] Ambiguous Method Call Error PR2365
• Add location info to `Rust::Identifier` PR2364
• Replace default initialization ```Location ()``` with ```UNDEF<sub>LOCATION</sub>``` PR2363
• Change class Location into typedef PR2362
• gccrs: minor HIR interface cleanup PR2360
• Create MacroInvocLexerBase PR2351
• Remove unnecessary methods/fields of `Rust::Lexer` PR2347
• nr2.0: Add `ForeverStack` data structure. PR2344
• nr2.0: Add basic Rib class PR2343
• nr2.0: Add complex testcases PR2342
• Ast collector fixes PR2340
• Remove old uses of Optional<T> PR2328
• optional: Import tl’s optional type PR2327
• util: Add tl::expected type PR2317
• Add proc macro resolve mappings PR2300
• Ignore semicolon following a macro expansion in expression context PR2292
• Rework the HIR dump pass PR2261
• Improve keyword check while parsing a macro match PR2222

Contributors this month

• Raiki Tamura
• Mahad Muhammad
• Owen Avery
• Pierre-Emmanuel Patry
• Marc Poulhiès

Overall Task Status

Test Cases

Bugs

Milestones Progress

Note that the intrinsics milestone percentage on github is not representative: It shows a 73% completion rate, but does not take into account the tracking issues with dozens of unresolved items. Thus the percentage is computed using the sum of issues and tracked items done divided by the sums of issues and tracked items overall. Similarly, the Update GCC’s master branch milestone contains a tracking issue containing over 200 tasks. The percentage shown here takes this into account.

Testing project

Planned Activities

• Finish late name resolution 2.0
• Look at procedural macro name resolution
• Fix remaining type systems bugs for core 1.49
• Opaque types
• Drop marker trait

Detailed changelog

HIR Dump

We now have a great starting point to a working HIR dump. It does not conform directly to Rustc but we don’t need it to. We have desperatly needed this for quite some time to help newer developers debug in the backend code generation as well as the typesystem and HIR lints. The HIR contains a bunch of mapping information and these ID’s are crucial to help with debugging issues.

Crate [                                                                                                                                                                      
        inner_attrs: empty                                                            
        mapping: [C: 0 Nid: 72 Hid: 59]                                                                                                                                      
        items {                                                                                                                                                              
                Trait [                                                                                                                                                      
                        mapping: [C: 0 Nid: 6 Hid: 21 Lid: 2]                                                                                                                
                        outer_attributes {                                                                                                                                   
                                lang = sized                                                                                                                                 
                        } // outer_attributes                                                                                                                                
                        visibility: pub                                                                                                                                      
                        unsafety: 0                                                   
                        name: Sized                                                                                                                                          
                        generic_params {                                                                                                                                     
                                TypeParam [                                                                                                                                  
                                        outer_attr:                                                                                                                          
                                        type_representation: Self                                                                                                            
                                        type_param_bounds: empty                                                                                                             
                                        type: none                                                                                                                           
                                ] // TypeParam                                                                                                                               
                        } // generic_params 
                        type_param_bounds: empty
                        where clause: none
                        trait_items: empty
                ] // Trait
                TupleStruct [
                        mapping: [C: 0 Nid: 20 Hid: 29 Lid: 8]
                        outer_attributes: empty
                        visibility: private 
                        struct_name: GenericStruct
                        generic_params {
                                TypeParam [ 
                                        outer_attr: 
                                        type_representation: T
                                        type_param_bounds: empty
                                        type: none
                                ] // TypeParam
                        } // generic_params 
                        where_clause: none
                        fields {

We will be making changes to this going forward but having a starting point gives us the chance to move forward.

More error codes

This month saw us adding these error codes to our diagnostics:

1. E0572
2. E0571
3. E0268
4. E0045
5. E0323
6. E0423
7. E0133
8. E0658
9. E0093
10. E0124
11. E0070
12. E0063
13. E0045
14. E0053
15. E0046
16. E0061
17. E0229
18. E0034

With the continued push forward with more error codes each week it shows GCC Rust is able to catch errors at the right points to emit these error codes. Lots have already been added this is just the list for this month.

Fix ICE with return expression outside of context

This was a nice bug to fix because you can’t return outside of a function context.

const FOO: u32 = return 0; 

This was an access to an empty stack which would not have been allowed if we wrote this in Rust. We now emit

test.rs:1:18: error: return statement outside of function body
    1 | const FOO: u32 = return 0;
      |                  ^~~~~~

Fix ICE when using full path to enum variant as part of a TypePath

It is not allowed to use the variant of an enum as a Type, rust enforces that you must use the Enum itself as a type. For example

enum Dragon {
    Born,
}

fn oblivion() -> Dragon::Born {
    Dragon::Born
}

We now emit:

test.rs:5:26: error: expected type, found variant of Dragon
    5 | fn oblivion() -> Dragon::Born {
      |                          ^~~~

Sized marker trait

In Rust all generic type parameters implement the Sized marker trait by default. This means for an example such as:

fn foo<T>(a:T) -> X { ... }

Will always get turned into:

#[lang = "sized"]
pub trait Sized {}

fn foo<T: Sized>(a:T) -> X { ... }

Types such as Slices, Dyn traits do not implement sized so we need to use the special syntax of ?Sized to remove the Sized trait obligation

#[lang = "sized"]
pub trait Sized {}

pub trait Trait {
    fn foo(&self) -> Self
    where
        Self: Sized;
}

pub fn static_foo<T: Trait + ?Sized>(_b: &T) {}

pub fn dynamic_bar(a: &dyn Trait) {
    static_foo(a)
}

Note in the example, Trait’s define an implicit Self type parameter which does not implemented Sized by default. This is because it would cause a recursive trait obligation for Sized to be defined on the Self for the Sized trait itself.

This is a key milestone for gccrs as it lays the groundwork to support the other major marker-trait of Drop. As the Sized trait is so intrinsic to Rust this has enforced us to update most of the testsuite to include this marker-trait.

Track Fn trait fn_onceoutput

In order to setup the Output associated type we can rely on using generic argument bindings. So for example when we have the FnOnce trait:

#[lang = "fn_once"]
pub trait FnOnce<Args> {
    #[lang = "fn_once_output"]
    type Output;

    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

Then we might have a function such as:

pub fn map<R, F: FnOnce(T) -> R>(self, f: F) -> Option<R> { ... }

For this trait bound predicate of FnOnce(T) -> R we use syntactic sugar to setup generics for the bound as if it was just another generic trait such as:

FnOnce<(T), Output=R>

Note the argument T is wrapped up implicitly inside a Tuple this keeps the type system consistent so you don’t need to have specific traits for numbers of arguments. Resuing argument binding means we can reuse our generic argument handling to get this support for free which is then consistent across the compiler.