support deprecated attribute in type constructors

CHANGELOG.md

@@ -51,6 +51,24 @@
 
 ### Compiler
 
+- The compiler now allows deprecating specific custome type variants using the `@deprecated` attribute:
+
+  ```gleam
+  pub type HashAlgor {
+    @deprecated("unsafe encription")
+    MD5
+    SHA224
+    SHA512
+  }
+
+  pub fn hash_password(input: String) -> String {
+    let results = hashing_lib.hash_input(input:, algo: MD5) // warning: MD5 is depreacated
+    results.hash
+  }
+  ```
+
+  ([Iesha](https://github.com/wilbert-mad))
+
 - The compiler now prints correctly qualified or aliased type names when
   printing type errors.
 

compiler-core/src/analyse.rs

@@ -823,7 +823,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             } => self.track_feature_usage(FeatureKind::InternalAnnotation, location),
         }
 
-        let constructors = constructors
+        let constructors: Vec<RecordConstructor<Arc<Type>>> = constructors
             .into_iter()
             .map(
                 |RecordConstructor {
@@ -832,8 +832,15 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                      name,
                      arguments: args,
                      documentation,
+                     deprecation: constructor_deprecation,
                  }| {
                     self.check_name_case(name_location, &name, Named::CustomTypeVariant);
+                    if constructor_deprecation.is_deprecated() {
+                        self.track_feature_usage(
+                            FeatureKind::VariantWithDeprecatedAnnotation,
+                            location,
+                        );
+                    }
 
                     let preregistered_fn = environment
                         .get_variable(&name)
@@ -868,6 +875,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                         name,
                         arguments: args,
                         documentation,
+                        deprecation: constructor_deprecation,
                     }
                 },
             )
@@ -878,6 +886,36 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             .parameters
             .clone();
 
+        // Check if all constructors are deprecated if so error.
+        if !constructors.is_empty()
+            && constructors
+                .iter()
+                .all(|record| record.deprecation.is_deprecated())
+        {
+            self.problems
+                .error(Error::AllVariantsDeprecated { location });
+        }
+
+        // If any constructor record/varient is deprecated while
+        // the type is deprecated as a whole that is considered an error.
+        if deprecation.is_deprecated()
+            && !constructors.is_empty()
+            && constructors
+                .iter()
+                .any(|record| record.deprecation.is_deprecated())
+        {
+            // Report error on all variants attibuted with deprecated
+            constructors
+                .iter()
+                .filter(|record| record.deprecation.is_deprecated())
+                .for_each(|record| {
+                    self.problems
+                        .error(Error::DeprecatedVariantOnDeprecatedType {
+                            location: record.location,
+                        });
+                });
+        }
+
         Ok(Definition::CustomType(CustomType {
             documentation: doc,
             location,
@@ -1014,11 +1052,19 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                 *publicity
             };
 
+            // If the whole custom type is deprecated all of its varints are too.
+            // Otherwise just the varint(s) attributed as deprecated are.
+            let deprecate_constructor = if deprecation.is_deprecated() {
+                deprecation
+            } else {
+                &constructor.deprecation
+            };
+
             environment.insert_module_value(
                 constructor.name.clone(),
                 ValueConstructor {
                     publicity: value_constructor_publicity,
-                    deprecation: deprecation.clone(),
+                    deprecation: deprecate_constructor.clone(),
                     type_: type_.clone(),
                     variant: constructor_info.clone(),
                 },
@@ -1042,7 +1088,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                 constructor_info,
                 type_,
                 value_constructor_publicity,
-                deprecation.clone(),
+                deprecate_constructor.clone(),
             );
 
             environment.names.named_constructor_in_scope(

compiler-core/src/ast.rs

@@ -232,6 +232,7 @@ pub struct RecordConstructor<T> {
     pub name: EcoString,
     pub arguments: Vec<RecordConstructorArg<T>>,
     pub documentation: Option<(u32, EcoString)>,
+    pub deprecation: Deprecation,
 }
 
 impl<A> RecordConstructor<A> {

compiler-core/src/error.rs

@@ -3129,6 +3129,52 @@ Try: _{}", kind_str.to_title_case(), name.to_snake_case()),
                         }),
                     }
                 },
+                        TypeError::AllVariantsDeprecated { location } => {
+                            let text = String::from("Consider deprecating the type as a whole.
+
+  @deprecated(\"message\")
+  type Wibble {
+    Wobble1
+    Wobble2
+  }
+");
+                            Diagnostic {
+                                title: "All variants of custom type deprecated.".into(),
+                                text,
+                                hint: None,
+                                level: Level::Error,
+                                location: Some(Location {
+                                    label: Label {
+                                        text: None,
+                                        span: *location,
+                                    },
+                                    path: path.clone(),
+                                    src: src.clone(),
+                                    extra_labels: vec![],
+                                })
+                            }
+                        },
+                        TypeError::DeprecatedVariantOnDeprecatedType{ location } => {
+                            let text = wrap("This custom type has already been deprecated, so deprecating \
+one of its variants does nothing.
+Consider removing the deprecation attribute on the variant.");
+
+                            Diagnostic {
+                                title: "Custom type already deprecated".into(),
+                                text,
+                                hint: None,
+                                level: Level::Error,
+                                location: Some(Location {
+                                    label: Label {
+                                        text: None,
+                                        span: *location,
+                                    },
+                                    path: path.clone(),
+                                    src: src.clone(),
+                                    extra_labels: vec![],
+                                })
+                            }
+                        }
             }
         }).collect_vec(),
 

compiler-core/src/format.rs

@@ -1566,17 +1566,18 @@ impl<'comments> Formatter<'comments> {
     ) -> Document<'a> {
         let comments = self.pop_comments(constructor.location.start);
         let doc_comments = self.doc_comments(constructor.location.start);
+        let attributes = AttributesPrinter::new()
+            .set_deprecation(&constructor.deprecation)
+            .to_doc();
 
         let doc = if constructor.arguments.is_empty() {
             if self.any_comments(constructor.location.end) {
-                constructor
-                    .name
-                    .as_str()
-                    .to_doc()
+                attributes
+                    .append(constructor.name.as_str().to_doc())
                     .append(self.wrap_args(vec![], constructor.location.end))
                     .group()
             } else {
-                constructor.name.as_str().to_doc()
+                attributes.append(constructor.name.as_str().to_doc())
             }
         } else {
             let args = constructor
@@ -1602,12 +1603,10 @@ impl<'comments> Formatter<'comments> {
                     },
                 )
                 .collect_vec();
-            constructor
-                .name
-                .as_str()
-                .to_doc()
-                .append(self.wrap_args(args, constructor.location.end))
-                .group()
+
+            attributes
+                .append(constructor.name.as_str().to_doc())
+                .append(self.wrap_args(args, constructor.location.end).group())
         };
 
         commented(doc_comments.append(doc).group(), comments)

compiler-core/src/language_server/engine.rs

@@ -729,7 +729,7 @@ fn custom_type_symbol(
                 } else {
                     SymbolKind::CONSTRUCTOR
                 },
-                tags: None,
+                tags: make_deprecated_symbol_tag(&constructor.deprecation),
                 deprecated: None,
                 range: src_span_to_lsp_range(full_constructor_span, line_numbers),
                 selection_range: src_span_to_lsp_range(constructor.name_location, line_numbers),

compiler-core/src/parse.rs

@@ -2145,6 +2145,24 @@ where
             let constructors = Parser::series_of(
                 self,
                 &|p| {
+                    // The only attribute supported on constructors is @deprecated
+                    let mut attributes = Attributes::default();
+                    let attr_loc = Parser::parse_attributes(p, &mut attributes)?;
+
+                    if let Some(attr_span) = attr_loc {
+                        // Expecting all but the deprecated atterbutes to be default
+                        if attributes.external_erlang.is_some()
+                            || attributes.external_javascript.is_some()
+                            || attributes.target.is_some()
+                            || attributes.internal != InternalAttribute::Missing
+                        {
+                            return parse_error(
+                                ParseErrorType::UnknownAttributeRecordVariant,
+                                attr_span,
+                            );
+                        }
+                    }
+
                     if let Some((c_s, c_n, c_e)) = Parser::maybe_upname(p) {
                         let documentation = p.take_documentation(c_s);
                         let (args, args_e) = Parser::parse_type_constructor_args(p)?;
@@ -2158,6 +2176,7 @@ where
                             name: c_n,
                             arguments: args,
                             documentation,
+                            deprecation: attributes.deprecated,
                         }))
                     } else {
                         Ok(None)
@@ -2193,6 +2212,7 @@ where
         } else {
             (vec![], end)
         };
+
         Ok(Some(Definition::CustomType(CustomType {
             documentation,
             location: SrcSpan { start, end },

compiler-core/src/parse/error.rs

@@ -327,6 +327,10 @@ utf16_codepoint, utf32_codepoint, signed, unsigned, big, little, native, size, u
                     "Hint: If a type is not generic you should omit the `()`.".into(),
                 ],
             ),
+            ParseErrorType::UnknownAttributeRecordVariant => (
+                "This attribute cannot be used on a variant.",
+                vec!["Hint: Did you mean `@deprecated`?".into()],
+            ),
         }
     }
 }
@@ -398,6 +402,7 @@ pub enum ParseErrorType {
     ConstantRecordConstructorNoArguments, // const x = Record()
     TypeConstructorNoArguments,           // let a : Int()
     TypeDefinitionNoArguments,            // pub type Wibble() { ... }
+    UnknownAttributeRecordVariant, // an attribute was used that is not know for a custom type variant
 }
 
 impl LexicalError {

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

@@ -0,0 +1,89 @@
+---
+source: compiler-core/src/parse/tests.rs
+assertion_line: 1512
+expression: "\ntype Wibble {\n    @deprecated(\"1\")\n    Wibble1\n    Wibble2\n}\n"
+---
+Parsed {
+    module: Module {
+        name: "",
+        documentation: [],
+        type_info: (),
+        definitions: [
+            TargetedDefinition {
+                definition: CustomType(
+                    CustomType {
+                        location: SrcSpan {
+                            start: 1,
+                            end: 12,
+                        },
+                        end_position: 61,
+                        name: "Wibble",
+                        name_location: SrcSpan {
+                            start: 6,
+                            end: 12,
+                        },
+                        publicity: Private,
+                        constructors: [
+                            RecordConstructor {
+                                location: SrcSpan {
+                                    start: 40,
+                                    end: 47,
+                                },
+                                name_location: SrcSpan {
+                                    start: 40,
+                                    end: 47,
+                                },
+                                name: "Wibble1",
+                                arguments: [],
+                                documentation: None,
+                                deprecation: Deprecated {
+                                    message: "1",
+                                },
+                            },
+                            RecordConstructor {
+                                location: SrcSpan {
+                                    start: 52,
+                                    end: 59,
+                                },
+                                name_location: SrcSpan {
+                                    start: 52,
+                                    end: 59,
+                                },
+                                name: "Wibble2",
+                                arguments: [],
+                                documentation: None,
+                                deprecation: NotDeprecated,
+                            },
+                        ],
+                        documentation: None,
+                        deprecation: NotDeprecated,
+                        opaque: false,
+                        parameters: [],
+                        typed_parameters: [],
+                    },
+                ),
+                target: None,
+            },
+        ],
+        names: Names {
+            local_types: {},
+            imported_modules: {},
+            type_variables: {},
+            local_value_constructors: {},
+        },
+    },
+    extra: ModuleExtra {
+        module_comments: [],
+        doc_comments: [],
+        comments: [],
+        empty_lines: [],
+        new_lines: [
+            0,
+            14,
+            35,
+            47,
+            59,
+            61,
+        ],
+    },
+}