Store attributes in the ParseProgram declaration types. (#2792)

This PR carries over any attributes that were parsed and stored in
`sway_ast::Module` into the `ParseProgram` decl types.

My primary motivation for adding this was so the language server could
access:
1. the attribute tokens so we can assign correct semantic information to
them for correct syntax highlighting
2. allow access to the doc attribute so we can provide in-editor
documentation pop-ups for hover requests.

See `sway-lsp/src/utils/attributes.rs` mod for the intended API for
accessing these tokens.

I did notice that in #1488 @ortho mentioned the next step would be to
pass the attributes into the AST. Feel free to let me know if you had
another idea for how these would be stored. I'm converting the
`AttributeDecl` into the `Attribute` type below which basically throws
away bracket & punctuation tokens and retains each of the `Ident`s. Then
the `AttributesMap` is what is stored in the AST. Similar to how it
worked before but now instead of having the map just store the vec of
args, it also stores the attribute name.

```rust
pub enum AttributeKind {
    Doc,
    Storage,
}

pub struct Attribute {
    pub name: Ident,
    pub args: Vec<Ident>,
}

pub type AttributesMap = HashMap<AttributeKind, Vec<Attribute>>;
```

sway-core/src/lib.rs

@@ -22,6 +22,7 @@ pub use asm_generation::from_ir::compile_ir_to_asm;
 use asm_generation::FinalizedAsm;
 pub use build_config::BuildConfig;
 use control_flow_analysis::ControlFlowGraph;
+pub use convert_parse_tree::{Attribute, AttributeKind, AttributesMap};
 use metadata::MetadataManager;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};

sway-core/src/parse_tree/declaration/constant.rs

@@ -1,13 +1,14 @@
 use crate::{
     parse_tree::{Expression, Visibility},
     type_system::TypeInfo,
+    AttributesMap,
 };
-
 use sway_types::{Ident, Span};
 
 #[derive(Debug, Clone)]
 pub struct ConstantDeclaration {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub type_ascription: TypeInfo,
     pub type_ascription_span: Option<Span>,
     pub value: Expression,

sway-core/src/parse_tree/declaration/enum.rs

@@ -1,10 +1,10 @@
-use crate::{parse_tree::Visibility, type_system::*};
-
+use crate::{parse_tree::Visibility, type_system::*, AttributesMap};
 use sway_types::{ident::Ident, span::Span};
 
 #[derive(Debug, Clone)]
 pub struct EnumDeclaration {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub type_parameters: Vec<TypeParameter>,
     pub variants: Vec<EnumVariant>,
     pub(crate) span: Span,
@@ -14,6 +14,7 @@ pub struct EnumDeclaration {
 #[derive(Debug, Clone)]
 pub struct EnumVariant {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub type_info: TypeInfo,
     pub type_span: Span,
     pub(crate) tag: usize,

sway-core/src/parse_tree/declaration/function.rs

@@ -1,5 +1,4 @@
-use crate::{parse_tree::*, type_system::*};
-
+use crate::{parse_tree::*, type_system::*, AttributesMap};
 use sway_types::{ident::Ident, span::Span};
 
 mod purity;
@@ -8,6 +7,7 @@ pub use purity::{promote_purity, Purity};
 #[derive(Debug, Clone)]
 pub struct FunctionDeclaration {
     pub purity: Purity,
+    pub attributes: AttributesMap,
     pub name: Ident,
     pub visibility: Visibility,
     pub body: CodeBlock,

sway-core/src/parse_tree/declaration/storage.rs

@@ -1,11 +1,11 @@
-use crate::{parse_tree::Expression, type_system::*};
-
+use crate::{parse_tree::Expression, type_system::*, AttributesMap};
 use sway_types::{ident::Ident, span::Span};
 
 #[derive(Debug, Clone)]
 /// A declaration of contract storage. Only valid within contract contexts.
 /// All values in this struct are mutable and persistent among executions of the same contract deployment.
 pub struct StorageDeclaration {
+    pub attributes: AttributesMap,
     pub fields: Vec<StorageField>,
     pub span: Span,
 }
@@ -17,6 +17,7 @@ pub struct StorageDeclaration {
 #[derive(Debug, Clone)]
 pub struct StorageField {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub type_info: TypeInfo,
     pub type_info_span: Span,
     pub initializer: Expression,

sway-core/src/parse_tree/declaration/struct.rs

@@ -1,13 +1,14 @@
 use crate::{
     parse_tree::Visibility,
     type_system::{TypeInfo, TypeParameter},
+    AttributesMap,
 };
-
 use sway_types::{ident::Ident, span::Span};
 
 #[derive(Debug, Clone)]
 pub struct StructDeclaration {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub fields: Vec<StructField>,
     pub type_parameters: Vec<TypeParameter>,
     pub visibility: Visibility,
@@ -17,6 +18,7 @@ pub struct StructDeclaration {
 #[derive(Debug, Clone)]
 pub struct StructField {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub type_info: TypeInfo,
     pub(crate) span: Span,
     pub type_span: Span,

sway-core/src/parse_tree/declaration/trait.rs

@@ -4,13 +4,14 @@ use crate::{
     function::Purity,
     parse_tree::{CallPath, Visibility},
     type_system::TypeInfo,
+    AttributesMap,
 };
-
 use sway_types::{ident::Ident, span::Span, Spanned};
 
 #[derive(Debug, Clone)]
 pub struct TraitDeclaration {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub interface_surface: Vec<TraitFn>,
     pub methods: Vec<FunctionDeclaration>,
     pub(crate) supertraits: Vec<Supertrait>,
@@ -28,9 +29,10 @@ impl Spanned for Supertrait {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct TraitFn {
     pub name: Ident,
+    pub attributes: AttributesMap,
     pub purity: Purity,
     pub parameters: Vec<FunctionParameter>,
     pub return_type: TypeInfo,

sway-core/src/semantic_analysis/ast_node/declaration/enum.rs

@@ -80,6 +80,7 @@ impl TypedEnumDeclaration {
             variants,
             span,
             visibility,
+            ..
         } = decl;
 
         // create a namespace for the decl, used to create a scope for generics

sway-core/src/semantic_analysis/ast_node/declaration/struct.rs

@@ -74,6 +74,7 @@ impl TypedStructDeclaration {
             type_parameters,
             visibility,
             span,
+            ..
         } = decl;
 
         // create a namespace for the decl, used to create a scope for generics

sway-core/src/semantic_analysis/ast_node/mod.rs

@@ -389,13 +389,18 @@ impl TypedAstNode {
                             ctx.namespace.insert_symbol(name, decl.clone());
                             decl
                         }
-                        Declaration::StorageDeclaration(StorageDeclaration { span, fields }) => {
+                        Declaration::StorageDeclaration(StorageDeclaration {
+                            span,
+                            fields,
+                            ..
+                        }) => {
                             let mut fields_buf = Vec::with_capacity(fields.len());
                             for StorageField {
                                 name,
                                 type_info,
                                 initializer,
                                 type_info_span,
+                                ..
                             } in fields
                             {
                                 let type_id = check!(
@@ -503,6 +508,7 @@ fn type_check_interface_surface(
                  parameters,
                  return_type,
                  return_type_span,
+                 ..
              }| TypedTraitFn {
                 name,
                 purity,

sway-core/src/semantic_analysis/namespace/module.rs

@@ -96,19 +96,20 @@ impl Module {
 
             // perform the conversions from parser code to parse tree types
             let name = const_item.name.clone();
+            let attributes = std::collections::HashMap::new();
             // convert to const decl
-            let const_decl =
-                match crate::convert_parse_tree::item_const_to_constant_declaration(ec, const_item)
-                {
-                    Ok(o) => o,
-                    Err(_emit_signal) => {
-                        // if an error was emitted, grab errors from the error context
-                        errors.append(&mut ec.errors.clone());
-                        warnings.append(&mut ec.warnings.clone());
-
-                        return err(warnings, errors);
-                    }
-                };
+            let const_decl = match crate::convert_parse_tree::item_const_to_constant_declaration(
+                ec, const_item, attributes,
+            ) {
+                Ok(o) => o,
+                Err(_emit_signal) => {
+                    // if an error was emitted, grab errors from the error context
+                    errors.append(&mut ec.errors.clone());
+                    warnings.append(&mut ec.warnings.clone());
+
+                    return err(warnings, errors);
+                }
+            };
 
             // Temporarily disallow non-literals. See https://github.com/FuelLabs/sway/issues/2647.
             if !matches!(const_decl.value.kind, ExpressionKind::Literal(_)) {

sway-lsp/src/utils/attributes.rs

@@ -0,0 +1,29 @@
+#![allow(dead_code)]
+use crate::core::token::{AstToken, Token};
+use sway_core::{Attribute, AttributeKind, AttributesMap, Declaration};
+
+pub(crate) fn attributes_map(token: &Token) -> Option<AttributesMap> {
+    match &token.parsed {
+        AstToken::Declaration(declaration) => match declaration {
+            Declaration::EnumDeclaration(decl) => Some(decl.attributes.clone()),
+            Declaration::FunctionDeclaration(decl) => Some(decl.attributes.clone()),
+            Declaration::StructDeclaration(decl) => Some(decl.attributes.clone()),
+            Declaration::ConstantDeclaration(decl) => Some(decl.attributes.clone()),
+            Declaration::StorageDeclaration(decl) => Some(decl.attributes.clone()),
+            _ => None,
+        },
+        AstToken::StorageField(field) => Some(field.attributes.clone()),
+        AstToken::StructField(field) => Some(field.attributes.clone()),
+        AstToken::TraitFn(trait_fn) => Some(trait_fn.attributes.clone()),
+        AstToken::EnumVariant(variant) => Some(variant.attributes.clone()),
+        _ => None,
+    }
+}
+
+pub(crate) fn doc_attributes(token: &Token) -> Option<Vec<Attribute>> {
+    attributes_map(token).and_then(|mut attributes| attributes.remove(&AttributeKind::Doc))
+}
+
+pub(crate) fn storage_attributes(token: &Token) -> Option<Vec<Attribute>> {
+    attributes_map(token).and_then(|mut attributes| attributes.remove(&AttributeKind::Storage))
+}

sway-lsp/src/utils/mod.rs

@@ -1,3 +1,4 @@
+pub(crate) mod attributes;
 pub(crate) mod common;
 pub mod debug;
 pub(crate) mod function;