Store information in TypedExpr::Invalid

GearsDatapacks · lpil · commit d3bd6d325559 · 2025-09-03T12:49:40.000+01:00
diff --git a/compiler-core/src/analyse.rs b/compiler-core/src/analyse.rs
@@ -628,6 +628,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                         start: body_location.end,
                         end: body_location.end,
                     },
+                    extra_information: None,
                 }));
                 let implementations = Implementations::supporting_all();
                 (
diff --git a/compiler-core/src/ast.rs b/compiler-core/src/ast.rs
@@ -6,7 +6,7 @@ mod untyped;
 mod tests;
 pub mod visit;
 
-pub use self::typed::TypedExpr;
+pub use self::typed::{InvalidExpression, TypedExpr};
 pub use self::untyped::{FunctionLiteralKind, UntypedExpr};
 
 pub use self::constant::{Constant, TypedConstant, UntypedConstant};
diff --git a/compiler-core/src/ast/typed.rs b/compiler-core/src/ast/typed.rs
@@ -188,6 +188,10 @@ pub enum TypedExpr {
     Invalid {
         location: SrcSpan,
         type_: Arc<Type>,
+        /// Extra information about the invalid expression, useful for providing
+        /// addition help or information, such as code actions to fix invalid
+        /// states.
+        extra_information: Option<InvalidExpression>,
     },
 }
 
@@ -1162,3 +1166,11 @@ impl bit_array::GetLiteralValue for TypedExpr {
         }
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum InvalidExpression {
+    ModuleSelect {
+        module_name: EcoString,
+        label: EcoString,
+    },
+}
diff --git a/compiler-core/src/ast/visit.rs b/compiler-core/src/ast/visit.rs
@@ -40,7 +40,7 @@
 
 use crate::{
     analyse::Inferred,
-    ast::{BitArraySize, TypedBitArraySize},
+    ast::{BitArraySize, TypedBitArraySize, typed::InvalidExpression},
     exhaustiveness::CompiledCase,
     type_::{
         ModuleValueConstructor, PatternConstructor, TypedCallArg, ValueConstructor,
@@ -335,8 +335,13 @@ pub trait Visit<'ast> {
         visit_typed_expr_negate_int(self, location, value)
     }
 
-    fn visit_typed_expr_invalid(&mut self, location: &'ast SrcSpan, type_: &'ast Arc<Type>) {
-        visit_typed_expr_invalid(self, location, type_);
+    fn visit_typed_expr_invalid(
+        &mut self,
+        location: &'ast SrcSpan,
+        type_: &'ast Arc<Type>,
+        extra_information: &'ast Option<InvalidExpression>,
+    ) {
+        visit_typed_expr_invalid(self, location, type_, extra_information);
     }
 
     fn visit_typed_statement(&mut self, stmt: &'ast TypedStatement) {
@@ -903,7 +908,11 @@ where
             v.visit_typed_expr_negate_bool(location, value)
         }
         TypedExpr::NegateInt { location, value } => v.visit_typed_expr_negate_int(location, value),
-        TypedExpr::Invalid { location, type_ } => v.visit_typed_expr_invalid(location, type_),
+        TypedExpr::Invalid {
+            location,
+            type_,
+            extra_information,
+        } => v.visit_typed_expr_invalid(location, type_, extra_information),
         TypedExpr::Echo {
             location,
             expression,
@@ -1843,8 +1852,12 @@ where
 {
 }
 
-pub fn visit_typed_expr_invalid<'a, V>(_v: &mut V, _location: &'a SrcSpan, _type_: &'a Arc<Type>)
-where
+pub fn visit_typed_expr_invalid<'a, V>(
+    _v: &mut V,
+    _location: &'a SrcSpan,
+    _type_: &'a Arc<Type>,
+    _extra_information: &'a Option<InvalidExpression>,
+) where
     V: Visit<'a> + ?Sized,
 {
 }
diff --git a/compiler-core/src/language_server/code_action.rs b/compiler-core/src/language_server/code_action.rs
@@ -4,11 +4,11 @@ use crate::{
     Error, STDLIB_PACKAGE_NAME, analyse,
     ast::{
         self, ArgNames, AssignName, AssignmentKind, BitArraySegmentTruncation, BoundVariable,
-        CallArg, CustomType, FunctionLiteralKind, ImplicitCallArgOrigin, Import, PIPE_PRECEDENCE,
-        Pattern, PatternUnusedArguments, PipelineAssignmentKind, Publicity, RecordConstructor,
-        SrcSpan, TodoKind, TypedArg, TypedAssignment, TypedClauseGuard, TypedExpr,
-        TypedModuleConstant, TypedPattern, TypedPipelineAssignment, TypedRecordConstructor,
-        TypedStatement, TypedUse, visit::Visit as _,
+        CallArg, CustomType, FunctionLiteralKind, ImplicitCallArgOrigin, Import, InvalidExpression,
+        PIPE_PRECEDENCE, Pattern, PatternUnusedArguments, PipelineAssignmentKind, Publicity,
+        RecordConstructor, SrcSpan, TodoKind, TypedArg, TypedAssignment, TypedClauseGuard,
+        TypedExpr, TypedModuleConstant, TypedPattern, TypedPipelineAssignment,
+        TypedRecordConstructor, TypedStatement, TypedUse, visit::Visit as _,
     },
     build::{Located, Module},
     config::PackageConfig,
@@ -3006,7 +3006,12 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractVariable<'ast> {
 
     // We don't want to offer the action if the cursor is over some invalid
     // piece of code.
-    fn visit_typed_expr_invalid(&mut self, location: &'ast SrcSpan, _type_: &'ast Arc<Type>) {
+    fn visit_typed_expr_invalid(
+        &mut self,
+        location: &'ast SrcSpan,
+        _type_: &'ast Arc<Type>,
+        _extra_information: &'ast Option<InvalidExpression>,
+    ) {
         let invalid_range = self.edits.src_span_to_lsp_range(*location);
         if within(self.params.range, invalid_range) {
             self.selected_expression = None;
@@ -5121,34 +5126,23 @@ impl<'ast> ast::visit::Visit<'ast> for GenerateFunction<'ast> {
         ast::visit::visit_typed_function(self, fun);
     }
 
-    fn visit_typed_expr_invalid(&mut self, location: &'ast SrcSpan, type_: &'ast Arc<Type>) {
-        let invalid_range = self.edits.src_span_to_lsp_range(*location);
-        if within(self.params.range, invalid_range) {
-            self.try_save_function_to_generate(*location, type_, None);
-        }
-
-        ast::visit::visit_typed_expr_invalid(self, location, type_);
-    }
-
-    fn visit_typed_expr_module_select(
+    fn visit_typed_expr_invalid(
         &mut self,
-        _location: &'ast SrcSpan,
-        _field_start: &'ast u32,
+        location: &'ast SrcSpan,
         type_: &'ast Arc<Type>,
-        label: &'ast EcoString,
-        module_name: &'ast EcoString,
-        _module_alias: &'ast EcoString,
-        constructor: &'ast ModuleValueConstructor,
+        extra_information: &'ast Option<InvalidExpression>,
     ) {
-        match constructor {
-            // Invalid module selects leave the `name` field blank
-            ModuleValueConstructor::Fn { name, .. } if name.is_empty() => {
-                self.try_save_function_from_other_module(module_name, label, type_, None);
+        let invalid_range = self.edits.src_span_to_lsp_range(*location);
+        if within(self.params.range, invalid_range) {
+            match extra_information {
+                Some(InvalidExpression::ModuleSelect { module_name, label }) => {
+                    self.try_save_function_from_other_module(module_name, label, type_, None)
+                }
+                None => self.try_save_function_to_generate(*location, type_, None),
             }
-            ModuleValueConstructor::Fn { .. }
-            | ModuleValueConstructor::Record { .. }
-            | ModuleValueConstructor::Constant { .. } => {}
         }
+
+        ast::visit::visit_typed_expr_invalid(self, location, type_, extra_information);
     }
 
     fn visit_typed_expr_call(
@@ -5168,23 +5162,25 @@ impl<'ast> ast::visit::Visit<'ast> for GenerateFunction<'ast> {
             }
 
             match fun {
-                TypedExpr::Invalid { type_, location } => {
-                    return self.try_save_function_to_generate(*location, type_, Some(arguments));
-                }
-                TypedExpr::ModuleSelect {
-                    module_name,
-                    label,
+                TypedExpr::Invalid {
                     type_,
-                    constructor: ModuleValueConstructor::Fn { name, .. },
-                    ..
-                } if name.is_empty() => {
+                    extra_information: Some(InvalidExpression::ModuleSelect { module_name, label }),
+                    location: _,
+                } => {
                     return self.try_save_function_from_other_module(
                         module_name,
                         label,
                         type_,
                         Some(arguments),
                     );
                 }
+                TypedExpr::Invalid {
+                    type_,
+                    location,
+                    extra_information: _,
+                } => {
+                    return self.try_save_function_to_generate(*location, type_, Some(arguments));
+                }
                 _ => {}
             }
         }
@@ -5494,12 +5490,17 @@ impl<'ast, IO> ast::visit::Visit<'ast> for GenerateVariant<'ast, IO>
 where
     IO: FileSystemReader + FileSystemWriter + BeamCompiler + CommandExecutor + Clone,
 {
-    fn visit_typed_expr_invalid(&mut self, location: &'ast SrcSpan, type_: &'ast Arc<Type>) {
+    fn visit_typed_expr_invalid(
+        &mut self,
+        location: &'ast SrcSpan,
+        type_: &'ast Arc<Type>,
+        extra_information: &'ast Option<InvalidExpression>,
+    ) {
         let invalid_range = src_span_to_lsp_range(*location, self.line_numbers);
         if within(self.params.range, invalid_range) {
             self.try_save_variant_to_generate(*location, type_, None);
         }
-        ast::visit::visit_typed_expr_invalid(self, location, type_);
+        ast::visit::visit_typed_expr_invalid(self, location, type_, extra_information);
     }
 
     fn visit_typed_expr_call(
diff --git a/compiler-core/src/type_/expression.rs b/compiler-core/src/type_/expression.rs
@@ -5,13 +5,14 @@ use crate::{
     ast::{
         Arg, Assert, Assignment, AssignmentKind, BinOp, BitArrayOption, BitArraySegment,
         CAPTURE_VARIABLE, CallArg, Clause, ClauseGuard, Constant, FunctionLiteralKind, HasLocation,
-        ImplicitCallArgOrigin, Layer, RECORD_UPDATE_VARIABLE, RecordBeingUpdated, SrcSpan,
-        Statement, TodoKind, TypeAst, TypedArg, TypedAssert, TypedAssignment, TypedClause,
-        TypedClauseGuard, TypedConstant, TypedExpr, TypedMultiPattern, TypedStatement,
-        USE_ASSIGNMENT_VARIABLE, UntypedArg, UntypedAssert, UntypedAssignment, UntypedClause,
-        UntypedClauseGuard, UntypedConstant, UntypedConstantBitArraySegment, UntypedExpr,
-        UntypedExprBitArraySegment, UntypedMultiPattern, UntypedStatement, UntypedUse,
-        UntypedUseAssignment, Use, UseAssignment,
+        ImplicitCallArgOrigin, InvalidExpression, Layer, RECORD_UPDATE_VARIABLE,
+        RecordBeingUpdated, SrcSpan, Statement, TodoKind, TypeAst, TypedArg, TypedAssert,
+        TypedAssignment, TypedClause, TypedClauseGuard, TypedConstant, TypedExpr,
+        TypedMultiPattern, TypedStatement, USE_ASSIGNMENT_VARIABLE, UntypedArg, UntypedAssert,
+        UntypedAssignment, UntypedClause, UntypedClauseGuard, UntypedConstant,
+        UntypedConstantBitArraySegment, UntypedExpr, UntypedExprBitArraySegment,
+        UntypedMultiPattern, UntypedStatement, UntypedUse, UntypedUseAssignment, Use,
+        UseAssignment,
     },
     build::Target,
     exhaustiveness::{self, CompileCaseResult, CompiledCase, Reachability},
@@ -728,6 +729,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         TypedExpr::Invalid {
             location,
             type_: self.new_unbound_var(),
+            extra_information: None,
         }
     }
 
@@ -1420,10 +1422,9 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                 }
             }
             // If module access failed because the module exists but that module does not export
-            // the referenced value, we return a `TypedExpr::ModuleSelect` instead of
-            // `TypedExpr::Invalid`, so that we have information about the attempted module select
-            // and can use it, for example, in the "Generate function" code action to support other
-            // modules.
+            // the referenced value, we return extra information about the invalid module select,
+            // so that we have information about the attempted module select and can use it, for
+            // example, in the "Generate function" code action to support other modules.
             (
                 _,
                 Some((
@@ -1446,23 +1447,10 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     type_with_same_name,
                     context,
                 });
-                TypedExpr::ModuleSelect {
+                TypedExpr::Invalid {
                     location,
-                    field_start: label_location.start,
                     type_: self.new_unbound_var(),
-                    label,
-                    module_alias: module_name.clone(),
-                    module_name,
-                    constructor: ModuleValueConstructor::Fn {
-                        location,
-                        module: "".into(),
-                        name: "".into(),
-                        external_erlang: None,
-                        external_javascript: None,
-                        field_map: None,
-                        documentation: None,
-                        purity: Purity::Unknown,
-                    },
+                    extra_information: Some(InvalidExpression::ModuleSelect { module_name, label }),
                 }
             }
             // If module access failed for some other reason, and no local variable shadows the
@@ -1472,6 +1460,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                 TypedExpr::Invalid {
                     location,
                     type_: self.new_unbound_var(),
+                    extra_information: None,
                 }
             }
             // In any other case use the record access for the error
@@ -1493,6 +1482,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     Err(_) => TypedExpr::Invalid {
                         location,
                         type_: self.new_unbound_var(),
+                        extra_information: None,
                     },
                 }
             }
@@ -4410,6 +4400,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                 value: TypedExpr::Invalid {
                     location,
                     type_: self.new_unbound_var(),
+                    extra_information: None,
                 },
                 implicit,
                 location,
@@ -4590,6 +4581,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                         end: body.last().location().end,
                     },
                     type_: body_typer.new_unbound_var(),
+                    extra_information: None,
                 }))
             };
 
diff --git a/compiler-core/src/type_/pipe.rs b/compiler-core/src/type_/pipe.rs
@@ -63,6 +63,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
                 TypedExpr::Invalid {
                     location: first_location,
                     type_: expr_typer.new_unbound_var(),
+                    extra_information: None,
                 }
             }
         };
@@ -149,6 +150,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
                             TypedExpr::Invalid {
                                 location,
                                 type_: self.expr_typer.new_unbound_var(),
+                                extra_information: None,
                             }
                         }
                     };
@@ -359,6 +361,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
                 TypedExpr::Invalid {
                     location: function_location,
                     type_: self.expr_typer.new_unbound_var(),
+                    extra_information: None,
                 }
             }
         });

Original file line number	Diff line number	Diff line change
`@@ -628,6 +628,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {`
`628`	`628`	`start: body_location.end,`
`629`	`629`	`end: body_location.end,`
`630`	`630`	`},`
	`631`	`+ extra_information: None,`
`631`	`632`	`}));`
`632`	`633`	`let implementations = Implementations::supporting_all();`
`633`	`634`	`(`
Original file line number	Diff line number	Diff line change
`@@ -188,6 +188,10 @@ pub enum TypedExpr {`
`188`	`188`	`Invalid {`
`189`	`189`	`location: SrcSpan,`
`190`	`190`	`type_: Arc<Type>,`
	`191`	`+ /// Extra information about the invalid expression, useful for providing`
	`192`	`+ /// addition help or information, such as code actions to fix invalid`
	`193`	`+ /// states.`
	`194`	`+ extra_information: Option<InvalidExpression>,`
`191`	`195`	`},`
`192`	`196`	`}`
`193`	`197`
`@@ -1162,3 +1166,11 @@ impl bit_array::GetLiteralValue for TypedExpr {`
`1162`	`1166`	`}`
`1163`	`1167`	`}`
`1164`	`1168`	`}`
	`1169`	`+`
	`1170`	`+#[derive(Debug, Clone, PartialEq, Eq)]`
	`1171`	`+pub enum InvalidExpression {`
	`1172`	`+ ModuleSelect {`
	`1173`	`+ module_name: EcoString,`
	`1174`	`+ label: EcoString,`
	`1175`	`+ },`
	`1176`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {`
`63`	`63`	`TypedExpr::Invalid {`
`64`	`64`	`location: first_location,`
`65`	`65`	`type_: expr_typer.new_unbound_var(),`
	`66`	`+ extra_information: None,`
`66`	`67`	`}`
`67`	`68`	`}`
`68`	`69`	`};`
`@@ -149,6 +150,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {`
`149`	`150`	`TypedExpr::Invalid {`
`150`	`151`	`location,`
`151`	`152`	`type_: self.expr_typer.new_unbound_var(),`
	`153`	`+ extra_information: None,`
`152`	`154`	`}`
`153`	`155`	`}`
`154`	`156`	`};`
`@@ -359,6 +361,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {`
`359`	`361`	`TypedExpr::Invalid {`
`360`	`362`	`location: function_location,`
`361`	`363`	`type_: self.expr_typer.new_unbound_var(),`
	`364`	`+ extra_information: None,`
`362`	`365`	`}`
`363`	`366`	`}`
`364`	`367`	`});`