Merge c4d35e4 into bf8d8a4

sway-core/src/build_config.rs

@@ -114,7 +114,9 @@ impl BuildConfig {
             time_phases: false,
             metrics_outfile: None,
             optimization_level: OptLevel::Opt0,
-            experimental: ExperimentalFlags::default(),
+            experimental: ExperimentalFlags {
+                new_encoding: false,
+            },
             lsp_mode: None,
         }
     }
@@ -203,7 +205,7 @@ impl BuildConfig {
     }
 }
 
-#[derive(Debug, Default, Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub struct ExperimentalFlags {
     pub new_encoding: bool,
 }

sway-core/src/ir_generation/const_eval.rs

@@ -1183,7 +1183,12 @@ mod tests {
     fn assert_is_constant(is_constant: bool, prefix: &str, expr: &str) {
         let engines = Engines::default();
         let handler = Handler::default();
-        let mut context = Context::new(engines.se(), sway_ir::ExperimentalFlags::default());
+        let mut context = Context::new(
+            engines.se(),
+            sway_ir::ExperimentalFlags {
+                new_encoding: false,
+            },
+        );
         let mut md_mgr = MetadataManager::default();
         let core_lib = namespace::Root::from(namespace::Module {
             name: Some(sway_types::Ident::new_no_span(

sway-core/src/ir_generation/function.rs

@@ -1823,7 +1823,18 @@ impl<'eng> FnCompiler<'eng> {
         // args and type parameters.  It's using the Sway types rather than IR types, which would
         // be more accurate but also more fiddly.
 
-        let (fn_key, item) = if !callee.span().as_str().is_empty() {
+        let no_span = callee.span().as_str().is_empty();
+        let is_autogenerated = if let Some(s) = callee.span.source_id() {
+            context
+                .source_engine
+                .get_path(s)
+                .starts_with("<autogenerated>")
+        } else {
+            false
+        };
+        let (fn_key, item) = if no_span || is_autogenerated {
+            (None, None)
+        } else {
             let fn_key = (
                 callee.span(),
                 callee
@@ -1833,12 +1844,11 @@ impl<'eng> FnCompiler<'eng> {
                     .collect(),
                 callee.type_parameters.iter().map(|tp| tp.type_id).collect(),
             );
+
             (
                 Some(fn_key.clone()),
                 self.recreated_fns.get(&fn_key).copied(),
             )
-        } else {
-            (None, None)
         };
 
         let new_callee = match item {

sway-core/src/lib.rs

@@ -91,7 +91,14 @@ pub fn parse(
     config: Option<&BuildConfig>,
 ) -> Result<(lexed::LexedProgram, parsed::ParseProgram), ErrorEmitted> {
     match config {
-        None => parse_in_memory(handler, engines, input),
+        None => parse_in_memory(
+            handler,
+            engines,
+            input,
+            ExperimentalFlags {
+                new_encoding: false,
+            },
+        ),
         // When a `BuildConfig` is given,
         // the module source may declare `dep`s that must be parsed from other files.
         Some(config) => parse_module_tree(
@@ -190,14 +197,15 @@ fn parse_in_memory(
     handler: &Handler,
     engines: &Engines,
     src: Arc<str>,
+    experimental: ExperimentalFlags,
 ) -> Result<(lexed::LexedProgram, parsed::ParseProgram), ErrorEmitted> {
     let mut hasher = DefaultHasher::new();
     src.hash(&mut hasher);
     let hash = hasher.finish();
     let module = sway_parse::parse_file(handler, src, None)?;
 
     let (kind, tree) = to_parsed_lang::convert_parse_tree(
-        &mut to_parsed_lang::Context::default(),
+        &mut to_parsed_lang::Context::new(BuildTarget::EVM, experimental),
         handler,
         engines,
         module.value.clone(),
@@ -481,7 +489,11 @@ pub fn parsed_to_ast(
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
 ) -> Result<ty::TyProgram, ErrorEmitted> {
-    let experimental = build_config.map(|x| x.experimental).unwrap_or_default();
+    let experimental = build_config
+        .map(|x| x.experimental)
+        .unwrap_or(ExperimentalFlags {
+            new_encoding: false,
+        });
     let lsp_config = build_config.map(|x| x.lsp_mode.clone()).unwrap_or_default();
 
     // Build the dependency graph for the submodules.

sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs

@@ -767,7 +767,6 @@ pub(crate) fn monomorphize_method_application(
             type_binding.as_mut().unwrap().type_arguments.to_vec_mut(),
         )?;
         let mut method = (*decl_engine.get_function(fn_ref)).clone();
-        method.is_trait_method_dummy = false;
 
         // Unify method type parameters with implementing type type parameters.
         if let Some(implementing_for_typeid) = method.implementing_for_typeid {

sway-core/src/semantic_analysis/namespace/module.rs

@@ -133,7 +133,7 @@ impl Module {
         let attributes = Default::default();
         // convert to const decl
         let const_decl_id = to_parsed_lang::item_const_to_constant_declaration(
-            &mut to_parsed_lang::Context::default(),
+            &mut to_parsed_lang::Context::new(crate::BuildTarget::EVM, experimental),
             handler,
             engines,
             const_item,

sway-core/src/semantic_analysis/program.rs

@@ -51,7 +51,12 @@ impl TyProgram {
         build_config: Option<&BuildConfig>,
         module_eval_order: ModuleEvaluationOrder,
     ) -> Result<Self, ErrorEmitted> {
-        let experimental = build_config.map(|x| x.experimental).unwrap_or_default();
+        let experimental =
+            build_config
+                .map(|x| x.experimental)
+                .unwrap_or(crate::ExperimentalFlags {
+                    new_encoding: false,
+                });
 
         let mut namespace = Namespace::init_root(initial_namespace);
         let mut ctx = TypeCheckContext::from_root(&mut namespace, engines, experimental)

sway-core/src/transform/to_parsed_lang/context.rs

@@ -1,6 +1,5 @@
 use crate::{build_config::ExperimentalFlags, language::parsed::TreeType, BuildTarget};
 
-#[derive(Default)]
 pub struct Context {
     pub experimental: ExperimentalFlags,
 
@@ -30,7 +29,11 @@ impl Context {
         Self {
             build_target,
             experimental,
-            ..Default::default()
+            module_has_configurable_block: std::default::Default::default(),
+            destructured_struct_unique_suffix: std::default::Default::default(),
+            destructured_tuple_unique_suffix: std::default::Default::default(),
+            match_expression_matched_value_unique_suffix: std::default::Default::default(),
+            program_type: std::default::Default::default(),
         }
     }
 

sway-ir/src/bin/opt.rs

@@ -26,7 +26,13 @@ fn main() -> Result<(), anyhow::Error> {
     let source_engine = SourceEngine::default();
 
     // Parse it. XXX Improve this error message too.
-    let mut ir = sway_ir::parser::parse(&input_str, &source_engine, ExperimentalFlags::default())?;
+    let mut ir = sway_ir::parser::parse(
+        &input_str,
+        &source_engine,
+        ExperimentalFlags {
+            new_encoding: false,
+        },
+    )?;
 
     // Perform optimisation passes in order.
     let mut passes = PassGroup::default();

sway-ir/src/context.rs

@@ -39,7 +39,7 @@ pub struct Context<'eng> {
     pub experimental: ExperimentalFlags,
 }
 
-#[derive(Copy, Clone, Default)]
+#[derive(Copy, Clone)]
 pub struct ExperimentalFlags {
     pub new_encoding: bool,
 }

sway-ir/src/irtype.rs

@@ -944,7 +944,12 @@ mod tests {
         static SOURCE_ENGINE: Lazy<SourceEngine> = Lazy::new(SourceEngine::default);
 
         fn create_context() -> Context<'static> {
-            Context::new(&SOURCE_ENGINE, ExperimentalFlags::default())
+            Context::new(
+                &SOURCE_ENGINE,
+                ExperimentalFlags {
+                    new_encoding: false,
+                },
+            )
         }
 
         /// Creates sample types that are not aggregates and do not point to

sway-ir/src/optimize.rs

@@ -81,7 +81,9 @@ pub mod tests {
             "
             ),
             &source_engine,
-            ExperimentalFlags::default(),
+            ExperimentalFlags {
+                new_encoding: false,
+            },
         )
         .unwrap();
 

sway-ir/tests/tests.rs

@@ -22,11 +22,17 @@ fn run_tests<F: Fn(&str, &mut Context) -> bool>(sub_dir: &str, opt_fn: F) {
         let input_bytes = std::fs::read(&path).unwrap();
         let input = String::from_utf8_lossy(&input_bytes);
 
-        let mut ir = sway_ir::parser::parse(&input, &source_engine, ExperimentalFlags::default())
-            .unwrap_or_else(|parse_err| {
-                println!("{}: {parse_err}", path.display());
-                panic!()
-            });
+        let mut ir = sway_ir::parser::parse(
+            &input,
+            &source_engine,
+            ExperimentalFlags {
+                new_encoding: false,
+            },
+        )
+        .unwrap_or_else(|parse_err| {
+            println!("{}: {parse_err}", path.display());
+            panic!()
+        });
 
         let first_line = input.split('\n').next().unwrap();
 

sway-lib-core/generate.sh

@@ -13,7 +13,7 @@ remove_generated_code "STRARRAY_ENCODE"
 START=1
 END=64
 for ((i=END;i>=START;i--)); do
-    CODE="impl AbiEncode for str[$i] { fn abi_encode(self, ref mut buffer: Buffer) { use ::str::*; let s = from_str_array(self); let len = s.len(); let ptr = s.as_ptr(); let mut i = 0; while i < len { let byte = ptr.add::<u8>(i).read::<u8>(); buffer.push(byte); i += 1; } } }"
+    CODE="impl AbiEncode for str[$i] { fn abi_encode(self, ref mut buffer: Buffer) { use ::str::*; let s = from_str_array(self); let len = s.len(); let ptr = s.as_ptr(); let mut i = 0; while i < len { let byte = ptr.add::<u8>(i).read::<u8>(); buffer.push_byte(byte); i += 1; } } }"
     sed -i "s/\/\/ BEGIN STRARRAY_ENCODE/\/\/ BEGIN STRARRAY_ENCODE\n$CODE/g" ./src/codec.sw
 done