parse opaque private types and error during analysis

The parser would previously error if it found `opaque` at the start of a type
definition and would only accept `pub opaque`. This would result in a confusing
error message, and analysis stopping altogether for the entire module.

With this change a private `opaque` type is actually parsed and the error is
deferred to the analysis step.

Author: giacomocavalieri

CHANGELOG.md

@@ -36,6 +36,34 @@
 
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- The compiler now emits a better error message for private types marked as
+  opaque. For example, the following piece of code:
+
+  ```gleam
+  opaque type Wibble {
+    Wobble
+  }
+  ```
+
+  Would result in the following error:
+
+  ```
+  error: Private opaque type
+    ┌─ /src/one/two.gleam:2:1
+    │
+  2 │ opaque type Wibble {
+    │ ^^^^^^ You can safely remove this.
+
+  Only a public type can be opaque.
+  ```
+
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
+- The parsing of opaque private types is now fault tolerant: having a private
+  opaque type in a module no longer stops the compiler from highlighting other
+  errors.
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 ### Build tool
 
 - New projects are generated using OTP28 on GitHub Actions.

compiler-core/src/analyse.rs

@@ -1326,6 +1326,15 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             });
         }
 
+        if *opaque && publicity.is_private() {
+            self.problems.error(Error::PrivateOpaqueType {
+                location: SrcSpan {
+                    start: location.start,
+                    end: location.start + 6,
+                },
+            });
+        }
+
         Ok(())
     }
 

compiler-core/src/error.rs

@@ -3877,6 +3877,22 @@ and explain your usecase for this pattern, and how you would expect it to behave
                             extra_labels: vec![],
                         }),
                     },
+
+                    TypeError::PrivateOpaqueType { location } => Diagnostic {
+                        title: "Private opaque type".to_string(),
+                        text: wrap("Only a public type can be opaque."),
+                        hint: None,
+                        level: Level::Error,
+                        location: Some(Location {
+                            label: Label {
+                                text: Some("You can safely remove this.".to_string()),
+                                span: *location,
+                            },
+                            path: path.clone(),
+                            src: src.clone(),
+                            extra_labels: vec![],
+                        }),
+                    },
                 })
                 .collect_vec(),
 

compiler-core/src/parse.rs

@@ -348,6 +348,13 @@ where
                 self.advance();
                 self.parse_custom_type(start, true, false, &mut attributes)
             }
+            (Some((start, Token::Opaque, _)), Some((_, Token::Type, _))) => {
+                // A private opaque type makes no sense! We still want to parse it
+                // and return an error later during the analysis phase.
+                self.advance();
+                self.advance();
+                self.parse_custom_type(start, false, true, &mut attributes)
+            }
 
             (t0, _) => {
                 self.tok0 = t0;

compiler-core/src/parse/snapshots/gleam_core__parse__tests__private_opaque_type_is_parsed.snap

@@ -0,0 +1,67 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "opaque type Wibble { Wobble }"
+---
+Parsed {
+    module: Module {
+        name: "",
+        documentation: [],
+        type_info: (),
+        definitions: [
+            TargetedDefinition {
+                definition: CustomType(
+                    CustomType {
+                        location: SrcSpan {
+                            start: 0,
+                            end: 18,
+                        },
+                        end_position: 29,
+                        name: "Wibble",
+                        name_location: SrcSpan {
+                            start: 12,
+                            end: 18,
+                        },
+                        publicity: Private,
+                        constructors: [
+                            RecordConstructor {
+                                location: SrcSpan {
+                                    start: 21,
+                                    end: 27,
+                                },
+                                name_location: SrcSpan {
+                                    start: 21,
+                                    end: 27,
+                                },
+                                name: "Wobble",
+                                arguments: [],
+                                documentation: None,
+                                deprecation: NotDeprecated,
+                            },
+                        ],
+                        documentation: None,
+                        deprecation: NotDeprecated,
+                        opaque: true,
+                        parameters: [],
+                        typed_parameters: [],
+                    },
+                ),
+                target: None,
+            },
+        ],
+        names: Names {
+            local_types: {},
+            imported_modules: {},
+            type_variables: {},
+            local_value_constructors: {},
+        },
+        unused_definition_positions: {},
+    },
+    extra: ModuleExtra {
+        module_comments: [],
+        doc_comments: [],
+        comments: [],
+        empty_lines: [],
+        new_lines: [],
+        trailing_commas: [],
+    },
+}

compiler-core/src/parse/tests.rs

@@ -1907,3 +1907,8 @@ fn operator_in_pattern_size() {
 fn correct_precedence_in_pattern_size() {
     assert_parse!("let assert <<size, payload:size(size + 2 * 8)>> = <<>>");
 }
+
+#[test]
+fn private_opaque_type_is_parsed() {
+    assert_parse_module!("opaque type Wibble { Wobble }");
+}

compiler-core/src/type_/error.rs

@@ -635,6 +635,19 @@ pub enum Error {
     NonUtf8StringAssignmentInBitArray {
         location: SrcSpan,
     },
+
+    /// This happens when a private type is marked as opaque. Only public types
+    /// can be opaque.
+    ///
+    /// ```gleam
+    /// opaque type Wibble {
+    ///   Wobble
+    /// }
+    /// ```
+    ///
+    PrivateOpaqueType {
+        location: SrcSpan,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -1198,8 +1211,8 @@ impl Error {
             | Error::IntOperatorOnFloats { location, .. }
             | Error::StringConcatenationWithAddInt { location }
             | Error::DoubleVariableAssignmentInBitArray { location }
-            | Error::NonUtf8StringAssignmentInBitArray { location } => location.start,
-
+            | Error::NonUtf8StringAssignmentInBitArray { location }
+            | Error::PrivateOpaqueType { location } => location.start,
             Error::UnknownLabels { unknown, .. } => {
                 unknown.iter().map(|(_, s)| s.start).min().unwrap_or(0)
             }

compiler-core/src/type_/tests/errors.rs

@@ -3283,3 +3283,14 @@ pub fn main() {
 "
     );
 }
+
+#[test]
+fn private_opaque_type() {
+    assert_module_error!(
+        "
+opaque type Wibble {
+  Wobble
+}
+"
+    );
+}

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__private_opaque_type.snap

@@ -0,0 +1,19 @@
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "\nopaque type Wibble {\n  Wobble\n}\n"
+---
+----- SOURCE CODE
+
+opaque type Wibble {
+  Wobble
+}
+
+
+----- ERROR
+error: Private opaque type
+  ┌─ /src/one/two.gleam:2:1
+  │
+2 │ opaque type Wibble {
+  │ ^^^^^^ You can safely remove this.
+
+Only a public type can be opaque.