CSY/reowolf Changeset - 8c870bc3cff3 · Centrum Wiskunde & Informatica (CWI)

Changeset - 8c870bc3cff3

Parent rev.

Child rev.

[Not reviewed]

0 4 0

mh - 4 years ago 2021-12-15 16:21:15
contact@maxhenger.nl

Implement tuple element selection

4 files changed with 131 insertions and 10 deletions:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_typing.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1647,6 +1647,12 @@ pub struct SlicingExpression { @@
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub enum SelectKind {
     StructField(Identifier),
     TupleMember(u64), // u64 is overkill, but space is taken up by `StructField` variant anyway
+}
 #[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
@@ @@ -1654,7 +1660,7 @@ pub struct SelectExpression { @@
     pub operator_span: InputSpan, // of the '.'
     pub full_span: InputSpan, // includes subject and field
     pub subject: ExpressionId,
-    pub field_name: Identifier,
+    pub kind: SelectKind,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -649,7 +649,15 @@ impl ASTWriter { @@
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Field").with_identifier_val(&expr.field_name);
                 match &expr.kind {
                     SelectKind::StructField(field_name) => {
                         self.kv(indent2).with_s_key("StructField").with_identifier_val(field_name);
                     },
                     SelectKind::TupleMember(member_index) => {
                         self.kv(indent2).with_s_key("TupleMember").with_disp_val(member_index);
                     },
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -1317,15 +1317,38 @@ impl PassDefinitions { @@
                     ));
+                }
             } else {
                 // Can be a select expression for struct fields, or a select
                 // for a tuple element.
                 debug_assert_eq!(token, TokenKind::Dot);
                 let subject = result;
                 let next = iter.next();
                 let (select_kind, full_span) = if Some(TokenKind::Integer) == next {
                     // Tuple member
                     let (index, index_span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, index_span.end
                     );
                     (SelectKind::TupleMember(index), full_span)
                 } else if Some(TokenKind::Ident) == next {
                     // Struct field
                     let field_name = consume_ident_interned(&module.source, iter, ctx)?;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, field_name.span.end
                     );
                     (SelectKind::StructField(field_name), full_span)
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         &module.source, iter.last_valid_pos(), "unexpected token: expected integer or identifier"
                     ));
                 };
                 result = ctx.heap.alloc_select_expression(|this| SelectExpression{
                     this, operator_span, full_span, subject, field_name,
                     this, operator_span, full_span, subject,
                     kind: select_kind,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 }).upcast();

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -2039,7 +2039,7 @@ impl PassTyping { @@
         let infer_expr = &self.expr_types[expr_idx as usize];
         let extra_idx = infer_expr.extra_data_idx;
-        fn determine_inference_type_instance<'a>(types: &'a TypeTable, infer_type: &InferenceType) -> Result<Option<&'a DefinedType>, ()> {
+        fn try_get_definition_id_from_inference_type<'a>(types: &'a TypeTable, infer_type: &InferenceType) -> Result<Option<&'a DefinedType>, ()> {
             for part in &infer_type.parts {
                 if part.is_marker() || !part.is_concrete() {
                     continue;
@@ @@ -2064,11 +2064,32 @@ impl PassTyping { @@
             Ok(None)
+        }
         fn try_get_tuple_size_from_inference_type(infer_type: &InferenceType) -> Result<Option<u32>, ()> {
             for part in &infer_type.parts {
                 if part.is_marker() || !part.is_concrete() {
                     continue;
+                }
                 if let InferenceTypePart::Tuple(size) = part {
                     return Ok(Some(*size));
                 } else {
                     // Expected a tuple
                     return Err(());
+                }
+            }
             // Type is not "defined enough" yet
             Ok(None)
+        }
         let (progress_subject, progress_expr) = match &select_expr.kind {
             SelectKind::StructField(field_name) => {
                 // Handle select of a struct's field
                 if infer_expr.field_or_monomorph_idx < 0 {
                     // We don't know the field or the definition it is pointing to yet
                     // Not yet known, check if we can determine it
                     let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;
-            let type_def = determine_inference_type_instance(&ctx.types, subject_type);
+                    let type_def = try_get_definition_id_from_inference_type(&ctx.types, subject_type);
                     match type_def {
                         Ok(Some(type_def)) => {
@@ @@ -2078,7 +2099,7 @@ impl PassTyping { @@
                                 struct_def
                             } else {
                                 return Err(ParseError::new_error_at_span(
-                            &ctx.module().source, select_expr.field_name.span, format!(
+                                    &ctx.module().source, field_name.span, format!(
                                         "Can only apply field access to structs, got a subject of type '{}'",
                                         subject_type.display_name(&ctx.heap)
+                                    )
@@ @@ -2088,7 +2109,7 @@ impl PassTyping { @@
                             let mut struct_def_id = None;
                             for (field_def_idx, field_def) in struct_def.fields.iter().enumerate() {
-                        if field_def.identifier == select_expr.field_name {
+                                if field_def.identifier == *field_name {
                                     // Set field definition and index
                                     let infer_expr = &mut self.expr_types[expr_idx as usize];
                                     infer_expr.field_or_monomorph_idx = field_def_idx as i32;
@@ @@ -2100,7 +2121,7 @@ impl PassTyping { @@
                             if struct_def_id.is_none() {
                                 let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();
                                 return Err(ParseError::new_error_at_span(
-                            &ctx.module().source, select_expr.field_name.span, format!(
+                                    &ctx.module().source, field_name.span, format!(
                                         "this field does not exist on the struct '{}'",
                                         ast_struct_def.identifier.value.as_str()
+                                    )
@@ @@ -2118,7 +2139,7 @@ impl PassTyping { @@
                         },
                         Err(()) => {
                             return Err(ParseError::new_error_at_span(
-                        &ctx.module().source, select_expr.field_name.span, format!(
+                                &ctx.module().source, field_name.span, format!(
                                     "Can only apply field access to structs, got a subject of type '{}'",
                                     subject_type.display_name(&ctx.heap)
+                                )
@@ @@ -2177,6 +2198,65 @@ impl PassTyping { @@
                     poly_data, &poly_progress, signature_type, expr_type
                 );
                 (progress_subject, progress_expr)
             },
             SelectKind::TupleMember(member_index) => {
                 let member_index = *member_index;
                 if infer_expr.field_or_monomorph_idx < 0 {
                     // We don't know what kind of tuple we're accessing yet
                     let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;
                     let tuple_size = try_get_tuple_size_from_inference_type(subject_type);
                     match tuple_size {
                         Ok(Some(enum_size)) => {
                             // Make sure we don't access an element outside of
                             // the tuple's bounds
                             if member_index >= enum_size as u64 {
                                 return Err(ParseError::new_error_at_span(
                                     &ctx.module().source, select_expr.full_span, format!(
                                         "element index {} is out of bounds, tuple has {} elements",
                                         member_index, enum_size
+                                    )
                                 ));
+                            }
                             // Within bounds, so set the index (such that we
                             // will not perform this lookup again)
                             let infer_expr = &mut self.expr_types[expr_idx as usize];
                             infer_expr.field_or_monomorph_idx = member_index as i32;
                         },
                         Ok(None) => {
                             // Nothing is known about the tuple yet
                             return Ok(());
                         },
                         Err(()) => {
                             return Err(ParseError::new_error_at_span(
                                 &ctx.module().source, select_expr.full_span, format!(
                                     "Can only apply tuple element selection to tuples, got a subject of type '{}'",
                                     subject_type.display_name(&ctx.heap)
+                                )
                             ));
+                        }
+                    }
+                }
                 // If here then we know which member we're accessing. So seek
                 // that member in the subject type and apply inference.
                 let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;
                 let mut member_start_idx = 1;
                 for _ in 0..member_index {
                     member_start_idx = InferenceType::find_subtree_end_idx(&subject_type.parts, member_start_idx);
+                }
                 let (progress_expr, progress_subject) = self.apply_equal2_constraint(
                     ctx, upcast_id, upcast_id, 0, subject_id, member_start_idx
                 )?;
                 (progress_subject, progress_expr)
             },
         };
         if progress_subject { self.queue_expr(ctx, subject_id); }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
@@ @@ -3817,10 +3897,14 @@ impl PassTyping { @@
                 },
                 Expression::Select(expr) => {
                     let (poly_var, struct_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);
                     let field_name = match &expr.kind {
                         SelectKind::StructField(v) => v,
                         SelectKind::TupleMember(_) => unreachable!(), // because we're constructing a polymorph error, and tuple access does not deal with polymorphs
                     };
                     return ParseError::new_error_at_span(
                         &ctx.module().source, expr.full_span, format!(
                             "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'",
-                            poly_var, expr.field_name.value.as_str(), struct_name
                             poly_var, field_name.value.as_str(), struct_name
+                        )
+                    )
+                }

0 comments (0 inline, 0 general)