Fix non idiomatic style lints (FuelLabs#384)

* reimplement style diagnostics

* Use reimplemented stlye functions instead of inflector

* Add warning for non-SCREAMING_SNAKE_CASE const names

core_lang/src/error.rs

@@ -1,8 +1,7 @@
 use crate::parser::Rule;
 use crate::span::Span;
+use crate::style::{to_screaming_snake_case, to_snake_case, to_upper_camel_case};
 use crate::type_engine::{IntegerBits, TypeInfo};
-use inflector::cases::classcase::to_class_case;
-use inflector::cases::snakecase::to_snake_case;
 use std::fmt;
 use thiserror::Error;
 
@@ -192,6 +191,9 @@ pub enum Warning<'sc> {
     NonSnakeCaseFunctionName {
         name: &'sc str,
     },
+    NonScreamingSnakeCaseConstName {
+        name: &'sc str,
+    },
     LossOfPrecision {
         initial_type: IntegerBits,
         cast_to: IntegerBits,
@@ -233,23 +235,23 @@ impl<'sc> fmt::Display for Warning<'sc> {
                 "Struct name \"{}\" is not idiomatic. Structs should have a ClassCase name, like \
                  \"{}\".",
                 struct_name,
-                to_class_case(struct_name)
+                to_upper_camel_case(struct_name)
             )
             }
             NonClassCaseTraitName { name } => {
                 write!(f,
                 "Trait name \"{}\" is not idiomatic. Traits should have a ClassCase name, like \
                  \"{}\".",
                 name,
-                to_class_case(name)
+                to_upper_camel_case(name)
             )
             }
             NonClassCaseEnumName { enum_name } => write!(
                 f,
                 "Enum \"{}\"'s capitalization is not idiomatic. Enums should have a ClassCase \
                  name, like \"{}\".",
                 enum_name,
-                to_class_case(enum_name)
+                to_upper_camel_case(enum_name)
             ),
             NonSnakeCaseStructFieldName { field_name } => write!(
                 f,
@@ -263,7 +265,7 @@ impl<'sc> fmt::Display for Warning<'sc> {
                 "Enum variant name \"{}\" is not idiomatic. Enum variant names should be \
                  ClassCase, like \"{}\".",
                 variant_name,
-                to_class_case(variant_name)
+                to_upper_camel_case(variant_name)
             ),
             NonSnakeCaseFunctionName { name } => {
                 write!(f,
@@ -273,6 +275,15 @@ impl<'sc> fmt::Display for Warning<'sc> {
                 to_snake_case(name)
             )
             }
+            NonScreamingSnakeCaseConstName { name } => {
+                write!(
+                    f,
+                    "Constant name \"{}\" is not idiomatic. Constant names should be SCREAMING_SNAKE_CASE, like \
+                    \"{}\".",
+                    name,
+                    to_screaming_snake_case(name),
+                )
+            },
             LossOfPrecision {
                 initial_type,
                 cast_to,

core_lang/src/lib.rs

@@ -13,6 +13,7 @@ pub mod parse_tree;
 mod parser;
 pub mod semantic_analysis;
 mod span;
+mod style;
 pub(crate) mod type_engine;
 
 use crate::asm_generation::checks::check_invalid_opcodes;

core_lang/src/parse_tree/declaration/constant_declaration.rs

@@ -2,8 +2,10 @@ use crate::parse_tree::{Expression, Visibility};
 use crate::{type_engine::TypeInfo, Ident};
 
 use crate::build_config::BuildConfig;
-use crate::error::{err, ok, CompileResult};
+use crate::error::{err, ok, CompileResult, Warning};
 use crate::parser::Rule;
+use crate::span::Span;
+use crate::style::is_screaming_snake_case;
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone)]
@@ -19,6 +21,7 @@ impl<'sc> ConstantDeclaration<'sc> {
         pair: Pair<'sc, Rule>,
         config: Option<&BuildConfig>,
     ) -> CompileResult<'sc, ConstantDeclaration<'sc>> {
+        let path = config.map(|c| c.path());
         let mut warnings = Vec::new();
         let mut errors = Vec::new();
         let mut const_decl_parts = pair.into_inner();
@@ -56,14 +59,26 @@ impl<'sc> ConstantDeclaration<'sc> {
             warnings,
             errors
         );
+        let name = check!(
+            Ident::parse_from_pair(name_pair.clone(), config),
+            return err(warnings, errors),
+            warnings,
+            errors
+        );
+        assert_or_warn!(
+            is_screaming_snake_case(name.primary_name),
+            warnings,
+            Span {
+                span: name_pair.as_span(),
+                path,
+            },
+            Warning::NonScreamingSnakeCaseConstName {
+                name: name.primary_name,
+            }
+        );
         ok(
             ConstantDeclaration {
-                name: check!(
-                    Ident::parse_from_pair(name_pair, config),
-                    return err(warnings, errors),
-                    warnings,
-                    errors
-                ),
+                name,
                 type_ascription,
                 value,
                 visibility,

core_lang/src/parse_tree/declaration/enum_declaration.rs

@@ -9,8 +9,8 @@ use crate::{error::*, semantic_analysis::ast_node::TypedEnumDeclaration};
 use crate::{
     parse_tree::{declaration::TypeParameter, Visibility},
     semantic_analysis::ast_node::TypedEnumVariant,
+    style::is_upper_camel_case,
 };
-use inflector::cases::classcase::is_class_case;
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone)]
@@ -114,7 +114,7 @@ impl<'sc> EnumDeclaration<'sc> {
             errors
         );
         assert_or_warn!(
-            is_class_case(name.primary_name),
+            is_upper_camel_case(name.primary_name),
             warnings,
             Span {
                 span: enum_name.as_span(),
@@ -186,7 +186,7 @@ impl<'sc> EnumVariant<'sc> {
                     errors
                 );
                 assert_or_warn!(
-                    is_class_case(name.primary_name),
+                    is_upper_camel_case(name.primary_name),
                     warnings,
                     name.span.clone(),
                     Warning::NonClassCaseEnumVariantName {

core_lang/src/parse_tree/declaration/function_declaration.rs

@@ -2,9 +2,9 @@ use crate::build_config::BuildConfig;
 use crate::error::*;
 use crate::parse_tree::{declaration::TypeParameter, Visibility};
 use crate::span::Span;
+use crate::style::is_snake_case;
 use crate::type_engine::TypeInfo;
 use crate::{CodeBlock, Ident, Rule};
-use inflector::cases::snakecase::is_snake_case;
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone)]

core_lang/src/parse_tree/declaration/struct_declaration.rs

@@ -2,10 +2,9 @@ use crate::build_config::BuildConfig;
 use crate::parse_tree::{declaration::TypeParameter, Visibility};
 use crate::parser::Rule;
 use crate::span::Span;
+use crate::style::{is_snake_case, is_upper_camel_case};
 use crate::type_engine::TypeInfo;
 use crate::{error::*, Ident};
-use inflector::cases::classcase::is_class_case;
-use inflector::cases::snakecase::is_snake_case;
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone)]
@@ -89,7 +88,7 @@ impl<'sc> StructDeclaration<'sc> {
             errors
         );
         assert_or_warn!(
-            is_class_case(name.primary_name),
+            is_upper_camel_case(name.primary_name),
             warnings,
             span,
             Warning::NonClassCaseStructName {

core_lang/src/parse_tree/declaration/trait_declaration.rs

@@ -3,10 +3,9 @@ use crate::build_config::BuildConfig;
 use crate::parse_tree::TypeParameter;
 use crate::parser::Rule;
 use crate::span::Span;
+use crate::style::{is_snake_case, is_upper_camel_case};
 use crate::type_engine::TypeInfo;
 use crate::{error::*, Ident};
-use inflector::cases::classcase::is_class_case;
-use inflector::cases::snakecase::is_snake_case;
 use pest::iterators::Pair;
 
 #[derive(Debug, Clone)]
@@ -45,7 +44,7 @@ impl<'sc> TraitDeclaration<'sc> {
         );
         let span = name.span.clone();
         assert_or_warn!(
-            is_class_case(name_pair.as_str().trim()),
+            is_upper_camel_case(name_pair.as_str().trim()),
             warnings,
             span,
             Warning::NonClassCaseTraitName {