try method #1

Author: AlicanC

sway-core/src/asm_generation/checks.rs

@@ -6,6 +6,8 @@ use crate::asm_lang::allocated_ops::{AllocatedOp, AllocatedOpcode};
 use crate::asm_lang::*;
 use crate::error::*;
 
+use sway_ir::*;
+
 /// Checks for disallowed opcodes in non-contract code.
 /// i.e., if this is a script or predicate, we can't use certain contract opcodes.
 /// See https://github.com/FuelLabs/sway/issues/350 for details.
@@ -72,3 +74,43 @@ fn check_for_contract_opcodes(ops: &[AllocatedOp]) -> CompileResult<()> {
         err(vec![], errors)
     }
 }
+
+pub fn check_invalid_return(ir: &Context, module: &Module) -> CompileResult<()> {
+    let default_span =
+        sway_types::span::Span::new("no span found for opcode".into(), 0, 1, None).unwrap();
+    match module.get_kind(ir) {
+        Kind::Contract | Kind::Library => ok((), vec![], vec![]),
+        Kind::Predicate | Kind::Script => {
+            let entry_point_function = module
+                .function_iter(&ir)
+                .find(|func| func.get_name(&ir) == crate::constants::DEFAULT_ENTRY_POINT_FN_NAME)
+                .unwrap();
+
+            let ret_ty = entry_point_function.get_return_type(ir);
+
+            if type_has_ptr(&ir, &ret_ty) {
+                err(
+                    vec![],
+                    vec![CompileError::PointerReturnNotAllowedInMain {
+                        span: default_span.clone(),
+                    }],
+                )
+            } else {
+                ok((), vec![], vec![])
+            }
+        }
+    }
+}
+
+fn type_has_ptr(ir: &Context, ty: &Type) -> bool {
+    match ty {
+        Type::Pointer(_) => true,
+        Type::Array(aggregate) | Type::Union(aggregate) | Type::Struct(aggregate) => {
+            match aggregate.get_content(ir) {
+                AggregateContent::ArrayType(ty, _) => type_has_ptr(ir, ty),
+                AggregateContent::FieldTypes(tys) => tys.iter().any(|ty| type_has_ptr(ir, ty)),
+            }
+        }
+        _ => false,
+    }
+}

sway-core/src/asm_generation/from_ir.rs

@@ -1,6 +1,6 @@
 use super::{
     asm_builder::AsmBuilder,
-    checks::check_invalid_opcodes,
+    checks::{check_invalid_opcodes, check_invalid_return},
     finalized_asm::FinalizedAsm,
     programs::{AbstractProgram, ProgramKind},
     register_sequencer::RegisterSequencer,
@@ -25,6 +25,14 @@ pub fn compile_ir_to_asm(
     let mut errors: Vec<CompileError> = Vec::new();
 
     let module = ir.module_iter().next().unwrap();
+
+    check!(
+        check_invalid_return(&ir, &module),
+        return err(warnings, errors),
+        warnings,
+        errors
+    );
+
     let abstract_program = check!(
         compile_module_to_asm(RegisterSequencer::new(), ir, module),
         return err(warnings, errors),