Dereferencing operator . on tuple element access (#5552)

## Description

This PR implements tuple element access operator `.` for
[references](https://github.com/FuelLabs/sway-rfcs/blob/ironcev/amend-references/files/0010-references.sw).
The overall effort related to references is tracked in #5063.

`.` is defined for references to tuples using this recursive definition:
`<reference>.<element index> := (*<reference>).<element index>`.

This eliminates the need for the dereferencing operator `*` when working
with references to tuples:

```Sway
let t = (1, 2, 3);

let r = &&&t;

assert((***r).0 == r.0);
```
```Sway
let r = &&& ( &&(1, 2), &(3, 4) );
assert(r.0.0 == 1);
assert(r.1.1 == 4);
```

Additionally, the PR:
- creates `Diagnostic` for the `TupleIndexOutOfBounds` error.
- harmonizes the appearance of the `TupleIndexOutOfBounds` error in the
element access and reassignments.

## Demo

`TupleIndexOutOfBounds` in element access and reassignments before:

![Tuple index out of bounds -
Before](https://github.com/FuelLabs/sway/assets/4142833/38dc610e-c9c2-4ae9-a638-d3da3fc38ada)

New errors:

![Tuple index out of bounds -
After](https://github.com/FuelLabs/sway/assets/4142833/d1668f7d-15b6-4d76-8644-301d3871568d)

![Tuple element access requires a
tuple](https://github.com/FuelLabs/sway/assets/4142833/15c41cea-ccac-417c-9b7b-758dccbc43f8)

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: ironcev

sway-core/src/ir_generation/function.rs

@@ -1345,7 +1345,7 @@ impl<'eng> FnCompiler<'eng> {
 
         let referenced_type = self.engines.te().get_unaliased(referenced_ast_type);
 
-        let result = if referenced_type.is_copy_type() || referenced_type.is_reference_type() {
+        let result = if referenced_type.is_copy_type() || referenced_type.is_reference() {
             // For non aggregates, we need to return the value.
             // This means, loading the value the `ptr` is pointing to.
             self.current_block.append(context).load(ptr)
@@ -3005,7 +3005,7 @@ impl<'eng> FnCompiler<'eng> {
                     if initializer_val
                         .get_type(context)
                         .map_or(false, |ty| ty.is_ptr(context))
-                        && (init_type.is_copy_type() || init_type.is_reference_type())
+                        && (init_type.is_copy_type() || init_type.is_reference())
                     {
                         // It's a pointer to a copy type, or a reference behind a pointer. We need to dereference it.
                         // We can get a reference behind a pointer if a reference variable is passed to the ASM block.

sway-core/src/language/ty/expression/expression_variant.rs

@@ -103,6 +103,13 @@ pub enum TyExpressionVariant {
     TupleElemAccess {
         prefix: Box<TyExpression>,
         elem_to_access_num: usize,
+        /// Final resolved type of the `prefix` part
+        /// of the expression. This will always be
+        /// a [TypeId] of a tuple, never an alias
+        /// or a reference to a tuple.
+        /// The original parent might be an alias
+        /// or a direct or indirect reference to a
+        /// tuple.
         resolved_type_of_parent: TypeId,
         elem_to_access_span: Span,
     },

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

@@ -1855,7 +1855,7 @@ impl ty::TyExpression {
                 _ => {
                     return Err(handler.emit_err(CompileError::NotIndexable {
                         actually: engines.help_out(prefix_type_id).to_string(),
-                        span: prefix_span.clone(),
+                        span: prefix_span,
                     }))
                 }
             };

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

@@ -52,7 +52,7 @@ pub(crate) fn instantiate_struct_field_access(
                     actually: engines.help_out(prefix_type_id).to_string(),
                     storage_variable: None,
                     field_name: (&field_to_access).into(),
-                    span: prefix_span.clone(),
+                    span: prefix_span,
                 }))
             }
         };

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

@@ -1,7 +1,7 @@
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::Span;
 
-use crate::{language::ty, CompileError, Engines};
+use crate::{language::ty, CompileError, Engines, TypeInfo};
 
 pub(crate) fn instantiate_tuple_index_access(
     handler: &Handler,
@@ -12,33 +12,69 @@ pub(crate) fn instantiate_tuple_index_access(
     span: Span,
 ) -> Result<ty::TyExpression, ErrorEmitted> {
     let type_engine = engines.te();
-    let mut tuple_type_arg_to_access = None;
-    let type_info = type_engine.get(parent.return_type);
-    let type_args = type_info.expect_tuple(handler, engines, &parent.span)?;
-    for (pos, type_arg) in type_args.iter().enumerate() {
-        if pos == index {
-            tuple_type_arg_to_access = Some(type_arg.clone());
-        }
+
+    let mut current_prefix_te = Box::new(parent);
+    let mut current_type = type_engine.get_unaliased(current_prefix_te.return_type);
+
+    let prefix_type_id = current_prefix_te.return_type;
+    let prefix_span = current_prefix_te.span.clone();
+
+    // Create the prefix part of the final tuple element access expression.
+    // This might be an expression that directly evaluates to a tuple type,
+    // or an arbitrary number of dereferencing expressions where the last one
+    // dereference to a tuple type.
+    //
+    // We will either hit a tuple at the end or return an error, so the
+    // loop cannot be endless.
+    while !current_type.is_tuple() {
+        match &*current_type {
+            TypeInfo::Ref(referenced_type) => {
+                let referenced_type_id = referenced_type.type_id;
+
+                current_prefix_te = Box::new(ty::TyExpression {
+                    expression: ty::TyExpressionVariant::Deref(current_prefix_te),
+                    return_type: referenced_type_id,
+                    span: prefix_span.clone(),
+                });
+
+                current_type = type_engine.get_unaliased(referenced_type_id);
+            }
+            TypeInfo::ErrorRecovery(err) => return Err(*err),
+            _ => {
+                return Err(
+                    handler.emit_err(CompileError::TupleElementAccessOnNonTuple {
+                        actually: engines.help_out(prefix_type_id).to_string(),
+                        span: prefix_span,
+                        index,
+                        index_span,
+                    }),
+                )
+            }
+        };
     }
-    let tuple_type_arg_to_access = match tuple_type_arg_to_access {
-        Some(tuple_type_arg_to_access) => tuple_type_arg_to_access,
-        None => {
-            return Err(handler.emit_err(CompileError::TupleIndexOutOfBounds {
-                index,
-                count: type_args.len(),
-                span: index_span,
-            }));
-        }
+
+    let TypeInfo::Tuple(type_args) = &*current_type else {
+        panic!("The current type must be a tuple.");
     };
-    let exp = ty::TyExpression {
+
+    if type_args.len() <= index {
+        return Err(handler.emit_err(CompileError::TupleIndexOutOfBounds {
+            index,
+            count: type_args.len(),
+            tuple_type: engines.help_out(prefix_type_id).to_string(),
+            span: index_span,
+            prefix_span,
+        }));
+    }
+
+    Ok(ty::TyExpression {
         expression: ty::TyExpressionVariant::TupleElemAccess {
-            resolved_type_of_parent: parent.return_type,
-            prefix: Box::new(parent),
+            resolved_type_of_parent: current_prefix_te.return_type,
+            prefix: current_prefix_te,
             elem_to_access_num: index,
             elem_to_access_span: index_span,
         },
-        return_type: tuple_type_arg_to_access.type_id,
+        return_type: type_args[index].type_id,
         span,
-    };
-    Ok(exp)
+    })
 }

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

@@ -427,7 +427,9 @@ impl Items {
                             return Err(handler.emit_err(CompileError::TupleIndexOutOfBounds {
                                 index: *index,
                                 count: fields.len(),
-                                span: Span::join(full_span_for_error, index_span.clone()),
+                                tuple_type: engines.help_out(symbol).to_string(),
+                                span: index_span.clone(),
+                                prefix_span: full_span_for_error.clone(),
                             }));
                         }
                     };
@@ -460,11 +462,20 @@ impl Items {
                         span: full_span_for_error,
                     }));
                 }
-                (actually, ty::ProjectionKind::TupleField { .. }) => {
-                    return Err(handler.emit_err(CompileError::NotATuple {
-                        actually: engines.help_out(actually).to_string(),
-                        span: full_span_for_error,
-                    }));
+                (
+                    actually,
+                    ty::ProjectionKind::TupleField {
+                        index, index_span, ..
+                    },
+                ) => {
+                    return Err(
+                        handler.emit_err(CompileError::TupleElementAccessOnNonTuple {
+                            actually: engines.help_out(actually).to_string(),
+                            span: full_span_for_error,
+                            index: *index,
+                            index_span: index_span.clone(),
+                        }),
+                    );
                 }
                 (actually, ty::ProjectionKind::ArrayIndex { .. }) => {
                     return Err(handler.emit_err(CompileError::NotIndexable {

sway-core/src/type_system/info.rs

@@ -1053,13 +1053,6 @@ impl TypeInfo {
         }
     }
 
-    pub fn is_unit(&self) -> bool {
-        match self {
-            TypeInfo::Tuple(fields) => fields.is_empty(),
-            _ => false,
-        }
-    }
-
     // TODO-IG: Check all the usages of `is_copy_type`.
     pub fn is_copy_type(&self) -> bool {
         // XXX This is FuelVM specific.  We need to find the users of this method and determine
@@ -1084,7 +1077,14 @@ impl TypeInfo {
         }
     }
 
-    pub fn is_reference_type(&self) -> bool {
+    pub fn is_unit(&self) -> bool {
+        match self {
+            TypeInfo::Tuple(fields) => fields.is_empty(),
+            _ => false,
+        }
+    }
+
+    pub fn is_reference(&self) -> bool {
         matches!(self, TypeInfo::Ref(_))
     }
 
@@ -1096,6 +1096,10 @@ impl TypeInfo {
         matches!(self, TypeInfo::Struct(_))
     }
 
+    pub fn is_tuple(&self) -> bool {
+        matches!(self, TypeInfo::Tuple(_))
+    }
+
     pub(crate) fn apply_type_arguments(
         self,
         handler: &Handler,
@@ -1296,46 +1300,6 @@ impl TypeInfo {
         }
     }
 
-    /// Given a [TypeInfo] `self`, expect that `self` is a [TypeInfo::Tuple], or a
-    /// [TypeInfo::Alias] of a tuple type. Also, return the contents of the tuple.
-    ///
-    /// Note that this works recursively. That is, it supports situations where a tuple has a chain
-    /// of aliases such as:
-    ///
-    /// ```
-    /// type Alias1 = (u64, u64);
-    /// type Alias2 = Alias1;
-    ///
-    /// fn foo(t: Alias2) {
-    ///     let x = t.0;
-    /// }
-    /// ```
-    ///
-    /// Returns an error if `self` is not a [TypeInfo::Tuple] or a [TypeInfo::Alias] of a tuple
-    /// type, transitively.
-    pub(crate) fn expect_tuple(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        debug_span: &Span,
-    ) -> Result<Vec<TypeArgument>, ErrorEmitted> {
-        match self {
-            TypeInfo::Tuple(elems) => Ok(elems.to_vec()),
-            TypeInfo::Alias {
-                ty: TypeArgument { type_id, .. },
-                ..
-            } => engines
-                .te()
-                .get(*type_id)
-                .expect_tuple(handler, engines, debug_span),
-            TypeInfo::ErrorRecovery(err) => Err(*err),
-            a => Err(handler.emit_err(CompileError::NotATuple {
-                actually: engines.help_out(a).to_string(),
-                span: debug_span.clone(),
-            })),
-        }
-    }
-
     /// Given a [TypeInfo] `self`, expect that `self` is a [TypeInfo::Enum], or a [TypeInfo::Alias]
     /// of a enum type. Also, return the contents of the enum.
     ///

sway-error/src/error.rs

@@ -303,8 +303,13 @@ pub enum CompileError {
         field_name: IdentUnique,
         span: Span,
     },
-    #[error("This is a {actually}, not a tuple. Elements can only be access on tuples.")]
-    NotATuple { actually: String, span: Span },
+    #[error("This expression has type \"{actually}\", which is not a tuple. Elements can only be accessed on tuples.")]
+    TupleElementAccessOnNonTuple {
+        actually: String,
+        span: Span,
+        index: usize,
+        index_span: Span,
+    },
     #[error("This expression has type \"{actually}\", which is not an indexable type.")]
     NotIndexable { actually: String, span: Span },
     #[error("\"{name}\" is a {actually}, not an enum.")]
@@ -555,11 +560,13 @@ pub enum CompileError {
     InvalidOpcodeFromPredicate { opcode: String, span: Span },
     #[error("Array index out of bounds; the length is {count} but the index is {index}.")]
     ArrayOutOfBounds { index: u64, count: u64, span: Span },
-    #[error("Tuple index out of bounds; the arity is {count} but the index is {index}.")]
+    #[error("Tuple index {index} is out of bounds. The tuple has {count} element{}.", plural_s(*count))]
     TupleIndexOutOfBounds {
         index: usize,
         count: usize,
+        tuple_type: String,
         span: Span,
+        prefix_span: Span,
     },
     #[error("Constants cannot be shadowed. {variable_or_constant} \"{name}\" shadows constant with the same name.")]
     ConstantsCannotBeShadowed {
@@ -894,7 +901,7 @@ impl Spanned for CompileError {
             StructFieldDoesNotExist { field_name, .. } => field_name.span(),
             MethodNotFound { span, .. } => span.clone(),
             ModuleNotFound { span, .. } => span.clone(),
-            NotATuple { span, .. } => span.clone(),
+            TupleElementAccessOnNonTuple { span, .. } => span.clone(),
             NotAStruct { span, .. } => span.clone(),
             NotIndexable { span, .. } => span.clone(),
             FieldAccessOnNonStruct { span, .. } => span.clone(),
@@ -1818,6 +1825,42 @@ impl ToDiagnostic for CompileError {
                 },
                 help: vec![],
             },
+            TupleIndexOutOfBounds { index, count, tuple_type, span, prefix_span } => Diagnostic {
+                reason: Some(Reason::new(code(1), "Tuple index is out of bounds".to_string())),
+                issue: Issue::error(
+                    source_engine,
+                    span.clone(),
+                    format!("Tuple index {index} is out of bounds. The tuple has only {count} element{}.", plural_s(*count))
+                ),
+                hints: vec![
+                    Hint::info(
+                        source_engine,
+                        prefix_span.clone(),
+                        format!("This expression has type \"{tuple_type}\".")
+                    ),
+                ],
+                help: vec![],
+            },
+            TupleElementAccessOnNonTuple { actually, span, index, index_span } => Diagnostic {
+                reason: Some(Reason::new(code(1), "Tuple element access requires a tuple".to_string())),
+                issue: Issue::error(
+                    source_engine,
+                    span.clone(),
+                    format!("This expression has type \"{actually}\", which is not a tuple or a reference to a tuple.")
+                ),
+                hints: vec![
+                    Hint::info(
+                        source_engine,
+                        index_span.clone(),
+                        format!("Tuple element access happens here, on the index {index}.")
+                    )
+                ],
+                help: vec![
+                    "In Sway, tuple elements can be accessed on:".to_string(),
+                    format!("{}- tuples. E.g., `my_tuple.1`.", Indent::Single),
+                    format!("{}- references, direct or indirect, to tuples. E.g., `(&my_tuple).1` or `(&&&my_tuple).1`.", Indent::Single),
+                ],
+            },
            _ => Diagnostic {
                     // TODO: Temporary we use self here to achieve backward compatibility.
                     //       In general, self must not be used and will not be used once we
@@ -1861,7 +1904,7 @@ pub enum StructFieldUsageContext {
     StorageAccess,
     PatternMatching { has_rest_pattern: bool },
     StructFieldAccess,
-    // TODO: Distinguish between struct filed access and destructing
+    // TODO: Distinguish between struct field access and destructing
     //       once https://github.com/FuelLabs/sway/issues/5478 is implemented
     //       and provide specific suggestions for these two cases.
     //       (Destructing desugars to plain struct field access.)

test/src/e2e_vm_tests/test_programs/should_pass/language/references/dereferencing_operator_dot_on_tuples/Forc.lock

@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-F898797E7BC715F8"
+
+[[package]]
+name = "dereferencing_operator_dot_on_tuples"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-F898797E7BC715F8"
+dependencies = ["core"]

test/src/e2e_vm_tests/test_programs/should_pass/language/references/dereferencing_operator_dot_on_tuples/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "dereferencing_operator_dot_on_tuples"
+
+[dependencies]
+std = { path = "../../../../../../../../sway-lib-std" }