[move-to-yul] Setup experiments.

This PR sets up experiments for code generation and wires them to the test infra. This will be needed for the upcoming control flow graph optimizations, and down the road also for other things.

A new module `experiments.rs` is added which declares constants for experiments. An experiment can be activated on the command line with `--experiment=<name>`. In a baseline tests, one can add the comment
```
// experiment: <name>
```

... to the source. The test is then run both with and without the experiment, producing different baseline files.

A first experiment is used to supress generation of source info in baseline tests by default. This is useful because a lot of useless diffs are created if source positions only slightly shift. Source info will now only be generated during tests if `--experiment=capture-source-info` is set. Only one of our tests has this on, in order to ensure source info keeps being tested.

Closes: #88

Author: wrwg

language/evm/move-to-yul/src/experiments.rs

@@ -0,0 +1,27 @@
+// Copyright (c) The Diem Core Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// Container for experiments in the compiler. Those can be activated
+/// via the `--experiment=<name>` flag.
+///
+/// One can activate an experiment in a test source by using a comment as such:
+/// ```
+///   // experiment: <name>
+/// ```
+/// This can be repeated an arbitrary number of times. The test will then be run for
+/// the default configuration and for each of the named experiments separately (if it is a
+/// baseline test, a different baseline file will be generated each time).
+///
+/// Each new experiment should have a description and explicit note about its retention.
+///
+/// - Permanent: the experiment is available indefinitely
+/// - Temporary: the experiment is intended to be removed after some time. Please document
+///   the condition under which it can be removed.
+pub struct Experiment();
+
+impl Experiment {
+    /// Capture source information in baseline generation when running a test. By default,
+    /// during tests this is off.
+    /// Retention: permanent
+    pub const CAPTURE_SOURCE_INFO: &'static str = "capture-source-info";
+}

language/evm/move-to-yul/src/functions.rs

@@ -216,17 +216,19 @@ impl<'a> FunctionGenerator<'a> {
             bc.display(target, &BTreeMap::default())
         );
         let print_loc = || {
-            let loc = target.get_bytecode_loc(bc.get_attr_id());
-            emitln!(
-                ctx.writer,
-                "/// @src {}:{}:{}",
-                ctx.file_id_map
-                    .get(&loc.file_id())
-                    .expect("file id defined")
-                    .0,
-                loc.span().start(),
-                loc.span().end()
-            );
+            if ctx.options.generate_source_info() {
+                let loc = target.get_bytecode_loc(bc.get_attr_id());
+                emitln!(
+                    ctx.writer,
+                    "/// @src {}:{}:{}",
+                    ctx.file_id_map
+                        .get(&loc.file_id())
+                        .expect("file id defined")
+                        .0,
+                    loc.span().start(),
+                    loc.span().end()
+                );
+            }
         };
         let get_block = |l| label_map.get(l).expect("label has corresponding block");
         // Need to make a clone below to avoid cascading borrow problems. We don't want the

language/evm/move-to-yul/src/generator.rs

@@ -189,22 +189,24 @@ impl Generator {
             ctx.options.version(),
         );
         emitln!(ctx.writer);
-        let mut use_src_emitted = false;
-        for (file_no, file_path) in ctx
-            .file_id_map
-            .values()
-            .sorted_by(|(n1, _), (n2, _)| n1.cmp(n2))
-        {
-            let use_str = format!("{}:\"{}\"", file_no, file_path);
-            if !use_src_emitted {
-                emitln!(ctx.writer, "/// @use-src {}", use_str);
-                use_src_emitted = true;
-            } else {
-                emitln!(ctx.writer, "///        , {}", use_str)
+        if ctx.options.generate_source_info() {
+            let mut use_src_emitted = false;
+            for (file_no, file_path) in ctx
+                .file_id_map
+                .values()
+                .sorted_by(|(n1, _), (n2, _)| n1.cmp(n2))
+            {
+                let use_str = format!("{}:\"{}\"", file_no, file_path);
+                if !use_src_emitted {
+                    emitln!(ctx.writer, "/// @use-src {}", use_str);
+                    use_src_emitted = true;
+                } else {
+                    emitln!(ctx.writer, "///        , {}", use_str)
+                }
             }
+            emitln!(ctx.writer);
         }
         emitln!(ctx.writer);
-        emitln!(ctx.writer);
     }
 
     /// Generate optional creator (contract constructor).

language/evm/move-to-yul/src/lib.rs

@@ -6,12 +6,12 @@
 mod attributes;
 mod context;
 mod evm_transformation;
+mod experiments;
 mod functions;
 pub mod generator;
 mod native_functions;
 pub mod options;
 mod yul_functions;
-// mod object;
 
 use crate::{generator::Generator, options::Options};
 use anyhow::anyhow;

language/evm/move-to-yul/src/options.rs

@@ -1,10 +1,11 @@
 // Copyright (c) The Diem Core Contributors
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::experiments::Experiment;
 use codespan_reporting::diagnostic::Severity;
-use move_command_line_common::env::read_env_var;
 use structopt::StructOpt;
 
+/// Options for a run of the compiler.
 #[derive(StructOpt, Debug)]
 #[structopt(name = "move-to-yul", about = "Move Solidity Generator")]
 pub struct Options {
@@ -16,37 +17,49 @@ pub struct Options {
     pub named_address_mapping: Vec<String>,
     /// Output file name.
     #[structopt(short)]
-    #[structopt(long)]
+    #[structopt(long, default_value = "output.yul")]
     pub output: String,
     /// Solc executable
-    #[structopt(long)]
+    #[structopt(long, env = "SOLC_EXE", default_value = "solc")]
     pub solc_exe: String,
     /// Whether to dump bytecode to a file.
     #[structopt(long = "dump-bytecode")]
     pub dump_bytecode: bool,
+    /// Whether we generate code for tests.
+    #[structopt(long)]
+    pub testing: bool,
+    /// Active experiments.
+    #[structopt(short)]
+    #[structopt(long = "experiment")]
+    pub experiments: Vec<String>,
     /// Sources to compile (positional arg)
     pub sources: Vec<String>,
 }
 
 impl Default for Options {
     fn default() -> Self {
-        Self {
-            dependencies: vec![],
-            named_address_mapping: vec![],
-            output: "output.yul".to_string(),
-            solc_exe: read_env_var("SOLC_EXE"),
-            dump_bytecode: false,
-            sources: vec![],
-        }
+        Options::from_iter(std::iter::empty::<String>())
     }
 }
 
 impl Options {
+    /// Returns the least severity of diagnosis which shall be reported.
     pub fn report_severity(&self) -> Severity {
         Severity::Warning
     }
 
+    /// Returns the version of the tool.
     pub fn version(&self) -> &str {
         "0.0"
     }
+
+    /// Returns true if an experiment is on.
+    pub fn experiment_on(&self, name: &str) -> bool {
+        self.experiments.iter().any(|s| s == name)
+    }
+
+    /// Returns true if source info should be generated during tests.
+    pub fn generate_source_info(&self) -> bool {
+        !self.testing || self.experiment_on(Experiment::CAPTURE_SOURCE_INFO)
+    }
 }