Allow user to specify aliasing model for Miri

Co-authored-by: Jake Goulding <[email protected]>

Author: GoldsteinE

compiler/base/cargo-miri-playground

@@ -3,5 +3,5 @@
 set -eu
 
 export MIRI_SYSROOT=~/.cache/miri
-export MIRIFLAGS="-Zmiri-disable-isolation"
+export MIRIFLAGS="${MIRIFLAGS:-} -Zmiri-disable-isolation"
 exec cargo miri run

compiler/base/orchestrator/src/coordinator.rs

@@ -239,6 +239,12 @@ pub enum Channel {
     Nightly,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum AliasingModel {
+    Stacked,
+    Tree,
+}
+
 impl Channel {
     #[cfg(test)]
     pub(crate) const ALL: [Self; 3] = [Self::Stable, Self::Beta, Self::Nightly];
@@ -654,6 +660,7 @@ pub struct MiriRequest {
     pub channel: Channel,
     pub crate_type: CrateType,
     pub edition: Edition,
+    pub aliasing_model: AliasingModel,
     pub code: String,
 }
 
@@ -667,10 +674,18 @@ impl LowerRequest for MiriRequest {
     }
 
     fn execute_cargo_request(&self) -> ExecuteCommandRequest {
+        let mut miriflags = Vec::new();
+
+        if matches!(self.aliasing_model, AliasingModel::Tree) {
+            miriflags.push("-Zmiri-tree-borrows");
+        }
+
+        let miriflags = miriflags.join(" ");
+
         ExecuteCommandRequest {
             cmd: "cargo".to_owned(),
             args: vec!["miri-playground".to_owned()],
-            envs: Default::default(),
+            envs: HashMap::from_iter([("MIRIFLAGS".to_owned(), miriflags)]),
             cwd: None,
         }
     }
@@ -3939,6 +3954,7 @@ mod tests {
         channel: Channel::Nightly,
         crate_type: CrateType::Binary,
         edition: Edition::Rust2021,
+        aliasing_model: AliasingModel::Stacked,
         code: String::new(),
     };
 

tests/spec/features/tools_spec.rb

@@ -54,6 +54,30 @@ def code_with_undefined_behavior
     EOF
   end
 
+  scenario "configure Miri for tree borrows" do
+    editor.set code_valid_under_tree_borrows_but_not_stacked_borrows
+    in_advanced_options_menu { choose("tree") }
+    in_tools_menu { click_on("Miri") }
+
+    within(:output, :stdout) do
+      expect(page).to have_content %r{[1, 2]}, wait: 10
+    end
+
+    within(:output, :stderr) do
+      expect(page).to_not have_content %r{Undefined Behavior}
+    end
+  end
+
+  def code_valid_under_tree_borrows_but_not_stacked_borrows
+    <<~EOF
+    fn main() {
+        let val = [1u8, 2];
+        let ptr = &val[0] as *const u8;
+        let _val = unsafe { *ptr.add(1) };
+    }
+    EOF
+  end
+
   scenario "expand macros with the nightly compiler" do
     editor.set code_that_uses_macros
     in_tools_menu { click_on("Expand macros") }

ui/frontend/AdvancedOptionsMenu.tsx

@@ -1,17 +1,29 @@
 import React, { useCallback } from 'react';
 
 import { Either as EitherConfig, Select as SelectConfig } from './ConfigElement';
+import MenuAside from './MenuAside';
 import MenuGroup from './MenuGroup';
 import { useAppDispatch, useAppSelector } from './hooks';
 import * as config from './reducers/configuration';
 import * as selectors from './selectors';
-import { Backtrace, Edition } from './types';
+import { AliasingModel, Backtrace, Edition } from './types';
+
+const MIRI_TREE_BORROWS_URL = 'https://github.com/rust-lang/miri#user-content--zmiri-tree-borrows';
+
+const TreeBorrowAside: React.FC = () => (
+  <MenuAside>
+    Code that is accepted by <a href={MIRI_TREE_BORROWS_URL}>Tree Borrows</a> may be declared
+    undefined behavior in the future.
+  </MenuAside>
+);
 
 const AdvancedOptionsMenu: React.FC = () => {
   const isEditionDefault = useAppSelector(selectors.isEditionDefault);
   const edition = useAppSelector((state) => state.configuration.edition);
   const isBacktraceDefault = useAppSelector(selectors.isBacktraceDefault);
   const backtrace = useAppSelector((state) => state.configuration.backtrace);
+  const isAliasingModelDefault = useAppSelector(selectors.isAliasingModelDefault);
+  const aliasingModel = useAppSelector((state) => state.configuration.aliasingModel);
 
   const dispatch = useAppDispatch();
 
@@ -20,33 +32,52 @@ const AdvancedOptionsMenu: React.FC = () => {
     (b: Backtrace) => dispatch(config.changeBacktrace(b)),
     [dispatch],
   );
+  const changeAliasingModel = useCallback(
+    (b: AliasingModel) => dispatch(config.changeAliasingModel(b)),
+    [dispatch],
+  );
 
   return (
-    <MenuGroup title="Advanced options">
-      <SelectConfig
-        name="Edition"
-        value={edition}
-        isDefault={isEditionDefault}
-        onChange={changeEdition}
-      >
-        <option value={Edition.Rust2015}>2015</option>
-        <option value={Edition.Rust2018}>2018</option>
-        <option value={Edition.Rust2021}>2021</option>
-        <option value={Edition.Rust2024}>2024</option>
-      </SelectConfig>
-
-      <EitherConfig
-        id="backtrace"
-        name="Backtrace"
-        a={Backtrace.Enabled}
-        b={Backtrace.Disabled}
-        aLabel="On"
-        bLabel="Off"
-        value={backtrace}
-        isDefault={isBacktraceDefault}
-        onChange={changeBacktrace}
-      />
-    </MenuGroup>
+    <>
+      <MenuGroup title="Advanced options">
+        <SelectConfig
+          name="Edition"
+          value={edition}
+          isDefault={isEditionDefault}
+          onChange={changeEdition}
+        >
+          <option value={Edition.Rust2015}>2015</option>
+          <option value={Edition.Rust2018}>2018</option>
+          <option value={Edition.Rust2021}>2021</option>
+          <option value={Edition.Rust2024}>2024</option>
+        </SelectConfig>
+
+        <EitherConfig
+          id="backtrace"
+          name="Backtrace"
+          a={Backtrace.Enabled}
+          b={Backtrace.Disabled}
+          aLabel="On"
+          bLabel="Off"
+          value={backtrace}
+          isDefault={isBacktraceDefault}
+          onChange={changeBacktrace}
+        />
+      </MenuGroup>
+
+      <MenuGroup title="Miri">
+        <EitherConfig
+          id="aliasingModel"
+          name="Aliasing model"
+          a={AliasingModel.Stacked}
+          b={AliasingModel.Tree}
+          value={aliasingModel}
+          isDefault={isAliasingModelDefault}
+          onChange={changeAliasingModel}
+          aside={<TreeBorrowAside />}
+        />
+      </MenuGroup>
+    </>
   );
 };
 

ui/frontend/reducers/configuration.ts

@@ -1,6 +1,7 @@
 import { PayloadAction, createSlice } from '@reduxjs/toolkit';
 
 import {
+  AliasingModel,
   AssemblyFlavor,
   Backtrace,
   Channel,
@@ -36,6 +37,7 @@ interface State {
   mode: Mode;
   edition: Edition;
   backtrace: Backtrace;
+  aliasingModel: AliasingModel;
 }
 
 const initialState: State = {
@@ -58,6 +60,7 @@ const initialState: State = {
   mode: Mode.Debug,
   edition: Edition.Rust2024,
   backtrace: Backtrace.Disabled,
+  aliasingModel: AliasingModel.Stacked,
 };
 
 const slice = createSlice({
@@ -76,6 +79,10 @@ const slice = createSlice({
       state.backtrace = action.payload;
     },
 
+    changeAliasingModel: (state, action: PayloadAction<AliasingModel>) => {
+      state.aliasingModel = action.payload;
+    },
+
     changeChannel: (state, action: PayloadAction<Channel>) => {
       state.channel = action.payload;
     },
@@ -146,6 +153,7 @@ export const {
   changeAceTheme,
   changeAssemblyFlavor,
   changeBacktrace,
+  changeAliasingModel,
   changeChannel,
   changeDemangleAssembly,
   changeEdition,

ui/frontend/reducers/output/miri.ts

@@ -4,6 +4,7 @@ import * as z from 'zod';
 import { jsonPost, routes } from '../../api';
 import { State as RootState } from '../../reducers';
 import { miriRequestSelector } from '../../selectors';
+import { AliasingModel } from '../../types';
 
 const sliceName = 'output/miri';
 
@@ -21,6 +22,7 @@ interface State {
 interface MiriRequestBody {
   code: string;
   edition: string;
+  aliasingModel: AliasingModel;
 }
 
 const MiriResponseBody = z.object({

ui/frontend/selectors/index.ts

@@ -6,6 +6,7 @@ import {
   Backtrace,
   Channel,
   Edition,
+  AliasingModel,
   Focus,
   Orientation,
   PrimaryActionAuto,
@@ -147,6 +148,7 @@ export const rustfmtVersionDetailsText = createSelector(getRustfmt, versionDetai
 export const miriVersionDetailsText = createSelector(getMiri, versionDetails);
 
 const editionSelector = (state: State) => state.configuration.edition;
+export const aliasingModelSelector = (state: State) => state.configuration.aliasingModel;
 
 export const isNightlyChannel = createSelector(
   channelSelector,
@@ -181,8 +183,13 @@ export const isBacktraceDefault = (state: State) => (
 
 export const getBacktraceSet = createSelector(isBacktraceDefault, (b) => !b);
 
+export const isAliasingModelDefault = createSelector(
+  aliasingModelSelector,
+  aliasingModel => aliasingModel == AliasingModel.Stacked,
+);
+
 export const getAdvancedOptionsSet = createSelector(
-  isEditionDefault, isBacktraceDefault,
+  isEditionDefault, isBacktraceDefault, isAliasingModelDefault,
   (...areDefault) => !areDefault.every(n => n),
 );
 
@@ -391,7 +398,8 @@ export const formatRequestSelector = createSelector(
 export const miriRequestSelector = createSelector(
   editionSelector,
   codeSelector,
-  (edition, code) => ({ edition, code }),
+  aliasingModelSelector,
+  (edition, code, aliasingModel) => ({ edition, code, aliasingModel }),
 );
 
 export const macroExpansionRequestSelector = createSelector(

ui/frontend/types.ts

@@ -150,6 +150,11 @@ export enum Backtrace {
   Enabled = 'enabled',
 }
 
+export enum AliasingModel {
+  Stacked = 'stacked',
+  Tree = 'tree',
+}
+
 export enum Focus {
   Clippy = 'clippy',
   Miri = 'miri',

ui/src/metrics.rs

@@ -361,6 +361,7 @@ impl HasLabelsCore for coordinator::MiriRequest {
             channel,
             crate_type,
             edition,
+            aliasing_model: _,
             code: _,
         } = *self;
 

ui/src/public_http_api.rs

@@ -103,6 +103,8 @@ pub(crate) struct MiriRequest {
     pub(crate) code: String,
     #[serde(default)]
     pub(crate) edition: String,
+    #[serde(default, rename = "aliasingModel")]
+    pub(crate) aliasing_model: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize)]

ui/src/server_axum.rs

@@ -1285,12 +1285,22 @@ pub(crate) mod api_orchestrator_integration_impls {
         type Error = ParseMiriRequestError;
 
         fn try_from(other: api::MiriRequest) -> std::result::Result<Self, Self::Error> {
-            let api::MiriRequest { code, edition } = other;
+            let api::MiriRequest {
+                code,
+                edition,
+                aliasing_model,
+            } = other;
+
+            let aliasing_model = match aliasing_model {
+                Some(am) => parse_aliasing_model(&am)?,
+                None => AliasingModel::Stacked,
+            };
 
             Ok(MiriRequest {
                 channel: Channel::Nightly,     // TODO: use what user has submitted
                 crate_type: CrateType::Binary, // TODO: use what user has submitted
                 edition: parse_edition(&edition)?,
+                aliasing_model,
                 code,
             })
         }
@@ -1300,6 +1310,8 @@ pub(crate) mod api_orchestrator_integration_impls {
     pub(crate) enum ParseMiriRequestError {
         #[snafu(transparent)]
         Edition { source: ParseEditionError },
+        #[snafu(transparent)]
+        AliasingMode { source: ParseAliasingModelError },
     }
 
     impl From<WithOutput<MiriResponse>> for api::MiriResponse {
@@ -1521,6 +1533,20 @@ pub(crate) mod api_orchestrator_integration_impls {
         value: String,
     }
 
+    pub(crate) fn parse_aliasing_model(s: &str) -> Result<AliasingModel, ParseAliasingModelError> {
+        Ok(match s {
+            "stacked" => AliasingModel::Stacked,
+            "tree" => AliasingModel::Tree,
+            value => return ParseAliasingModelSnafu { value }.fail(),
+        })
+    }
+
+    #[derive(Debug, Snafu)]
+    #[snafu(display("'{value}' is not a valid aliasing model"))]
+    pub(crate) struct ParseAliasingModelError {
+        value: String,
+    }
+
     impl From<gist::Gist> for api::MetaGistResponse {
         fn from(me: gist::Gist) -> Self {
             api::MetaGistResponse {