Skip to content

Latest commit

 

History

History
157 lines (128 loc) · 8.44 KB

2019-12-05.md

File metadata and controls

157 lines (128 loc) · 8.44 KB

Lang Team Triage Meeting Minutes

Action items

  • propose case-by-case uplift for clippy lints (scottmcm) & cancel FCP

Resolutions

Shepherded item updates

const evaluation (ecstatic-morse)

  • Triaging/fixing bugs in const if/match
    • Now available on nightly; #![feature(const_if_match)]

ffi-unwind (BatmanAod)

  • no major updates this week
  • still waiting to finish the work on measuring the performance impact of ABI choice

"dyn Trait" stuff (nikomatsakis)

  • Relevant issue: rust-lang/rust#57893
  • Update:
    • started analyzing the breakage more closely
    • seem to have identified a few patterns of interest
      • impl<T: ?Sized + Foo> Bar for T -- a common case, and perhaps one where we could avoid requiring dyn trait prefix in older code?
    • in any case: seems like an important next step will be starting to draft an RFC
      • perhaps consider newer process?
      • Should have a meeting to discuss the problem, not just the solution, and also to brainstorm multiple potential solutions.

grammar (qmx)

  • no updates
  • some refactoring work on rustc parser taking place

Shepherding proposals

  • (~10 min) December 5th: Safe Transmute (let’s delegate Ryan Levick as shepherd)
    • looking to solve problem of safely transmuting from one type to another (&T to &U, or &T to &[u8], or &[u8] to &T)
    • also (where possible) supporting mutable transmutes
    • is this a problem lang+libs would like to solve and create a shepherded group
    • current proposal needs compiler support primarily to verify that a trait can be safely implemented (analogous to Copy)
      • but if it turns out we don't need lang support, we can always recharter this group
    • there are extensions that we would want to make in future rounds
      • and some of them would require changes to the language
      • in particular safe union reads
    • Proposed scope includes safe transmutes, safe transmutes of mutable references, and safe union field reads
    • compiler complexity: low (just verifying type requirements)
    • would want to survey past work and other crates
    • internals thread
    • sense of the meeting: positive
    • next steps:
  • (~15 min) December 5th: Inline assembly working group (let’s delegate Amanieu as shepherd)
    • pre-rfc posted on internals, based on an earlier pre-rfc
    • end-state:
      • asm! macro using a syntax we feel we can maintain, easily write, and stabilize
      • today we expose LLVM's assembler quite directly (and regularly hit issues with implementation, including ICEs), we would be moving away from that
    • architectures:
      • the goal is to support this on every major target
    • Why this feature now?
      • Keeping a lot of people on nightly (or on C) at the moment
      • Fits into the "C parity" goals
      • (Rust offers a compelling advantage here because of its portability story)
    • Proposed scope:
      • defining new assembly syntax
      • providing a transition story for the current asm!
      • defining fallback for backends without native support (e.g., cranelift)
      • secondary, future steps:
        • naked functions (transition story or interoperability story)
        • global asm
    • compiler complexity: moderate
      • what happens if we add other backends?
        • the pre-RFC describes how to implement it using an external assembler
        • in short you get a function call and rustc compiles the asm as a separate object file
    • next steps:

Triage

P-high issues

  • Regression in Error conversion from Infallible

    • Do we feel ok with doing nothing?
      • Breakage has to do with inference and hence it is 'allowed'
      • niko: I don't feel comfortable w/ the quantity
      • josh: also when we made the decision to stabilize we didn't expect breakage
      • centril: the breakage we were talking about was in the dynamic semantics
      • niko: it was unanticipated
    • Currently this is on nightly
    • Possible fixes enumerated by
      • 1 -- unacceptable
      • 2 -- time doesn't seem sufficient before this hits beta
        • what does it mean to "complete mitigations"?
        • we have a number of mitigations in place, but we don't have a lint that detects the regression that happened in objc
      • 3 -- we don't have consensus on it, but it would be doable in time
      • 4 -- time doesn't seem sufficient before this hits beta
      • 5 -- give up on a major use case for !
        • only known way to (at least partially) recover would be making ! and uninhabited types inter-coercible
        • but that is a bigger piece of work with unknown end result
      • 6 -- unaccepable by T-libs
      • 7 -- would buy time to work towards 2, for instance
        • but centril would ask someone else to do the work
          • niko raises hand

  • Pin is unsound due to rogue Deref/DerefMut implementations rust-lang/rust#66544

    • this requires resolution

  • Coherence can be bypassed by an indirect impl for a trait object

Nominated PRs

Nominated issues

Nominated RFCs

rfcbot pending list

Future meeting proposals

  • dereference with ralfjung / compiler’s llvm-wg / ucg wg?