[Metadata] Initial redesign (#2396)

An initial redesign of the metadata table. This PR ended up a little
chunky, so to break things down it does the following:
- Introduces a `SetAttribute` to Calyx which stores multiple unique
numbers rather than only one. The syntax is `@Attribute_name{ n1, n2, n3
}` and `"attribute_name"={ n1, n2, n3 }` depending on the context.
- Move `pos` from `Attribute` to `SetAttribute`. If a `pos` attribute is
written with the standard syntax, the compiler will emit a warning and
ignore the attribute. E.g. `@pos(1)` is incorrect and will be ignored
since it should be `@pos{1}`.
- Also adds an `Unknown` set attribute, which works the same as its
corresponding variant in the standard attributes
- Adds a new `MetadataTable` construct which is parsed in a `fileinfo #{
.. }#` block and made available in the `Workspace` and `Context`
structures as an optional field.
- At present, the table maps file identifiers to paths and positions to
pairs of files and line numbers. We will likely want to extend this in
the future.
- The actual syntax of the table is a very basic placeholder which we
can iterate on later as needed
- There is currently a limited metadata lookup construct which will read
the file contents into memory and return the given lines. It's pretty
brittle right now
- We may in the future want a special signifier for the current file /
input stream as calyx->calyx mappings will want this. Though perhaps
there is a better way of approaching this
- Also moves the cider index implementation into a separate crate
`cider-idx` as we were initially going to use that with the new table,
but we moved away from that approach for the moment, so these changes
are largely irrelevant. Didn't want to do git magic since it was already
pushed and the branch is being used by @ayakayorihiro.

Author: EclecticGriffin

Cargo.lock

@@ -20,6 +20,7 @@ members = [
     "tools/component_cells",
     "tools/yxi",
     "tools/calyx-writer",
+    "cider-idx",
 ]
 exclude = ["site"]
 
@@ -43,7 +44,7 @@ log = "0.4"
 string-interner = "0.14.0"
 lazy_static = "1"
 linked-hash-map = "0.5"
-smallvec = "1"
+smallvec = { version = "1", features = ["const_generics"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_sexpr = "0.1.0"

Cargo.toml

@@ -60,7 +60,13 @@ impl MlirBackend {
         } else {
             format!(
                 " {{{}}}",
-                attrs.to_string_with(", ", |k, v| { format!("{k}={v}") })
+                attrs.to_string_with(
+                    ", ",
+                    |k, v| { format!("{k}={v}") },
+                    // this is a placeholder for set attributes until they can
+                    // be added to the MLIR dialect
+                    |_, _| "".to_string()
+                )
             )
         }
     }

calyx-backend/src/mlir.rs

@@ -15,7 +15,7 @@ readme.workspace = true
 
 [features]
 default = []
-serialize = ["serde/derive", "dep:serde_with"]
+serialize = ["serde/derive", "dep:serde_with", "calyx-utils/serialize"]
 
 [dependencies]
 atty.workspace = true
@@ -30,6 +30,7 @@ pest_derive.workspace = true
 pest_consume.workspace = true
 itertools.workspace = true
 
+thiserror = "2"
 calyx-utils.workspace = true
 
 strum_macros = "0.25"

calyx-frontend/Cargo.toml

@@ -1,6 +1,6 @@
 //! Abstract Syntax Tree for Calyx
 use super::parser;
-use crate::{Attributes, PortDef, Primitive};
+use crate::{source_info::SourceInfoTable, Attributes, PortDef, Primitive};
 use atty::Stream;
 use calyx_utils::{CalyxResult, Error, GPosIdx, Id, PosString};
 use std::{num::NonZeroU64, path::PathBuf};
@@ -14,8 +14,10 @@ pub struct NamespaceDef {
     pub components: Vec<ComponentDef>,
     /// Extern statements and any primitive declarations in them.
     pub externs: Vec<(Option<PosString>, Vec<Primitive>)>,
-    /// Optional opaque metadata
+    /// Optional opaque metadata.
     pub metadata: Option<String>,
+    /// Optional Source Info table
+    pub source_info_table: Option<SourceInfoTable>,
 }
 
 impl NamespaceDef {

calyx-frontend/src/ast.rs

@@ -113,9 +113,6 @@ pub enum NumAttr {
     #[strum(serialize = "bound")]
     /// The bound of a while loop
     Bound,
-    #[strum(serialize = "pos")]
-    /// Source location position for this node
-    Pos,
     #[strum(serialize = "promotable")]
     /// Can promote the group, control, or @go port of the component to static
     /// with the annotated latency
@@ -162,6 +159,91 @@ impl From<InternalAttr> for Attribute {
     }
 }
 
+#[derive(
+    AsRefStr,
+    EnumString,
+    Clone,
+    Copy,
+    Hash,
+    PartialEq,
+    Eq,
+    Debug,
+    strum_macros::Display,
+    PartialOrd,
+    Ord,
+)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+pub enum SetAttr {
+    #[strum(serialize = "pos")]
+    /// Source location position for this node
+    Pos,
+}
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+pub enum SetAttribute {
+    Set(SetAttr),
+    Unknown(Id),
+}
+
+impl Ord for SetAttribute {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match (self, other) {
+            (SetAttribute::Set(s1), SetAttribute::Set(s2)) => s1.cmp(s2),
+            (SetAttribute::Set(_), SetAttribute::Unknown(_)) => {
+                std::cmp::Ordering::Less
+            }
+            (SetAttribute::Unknown(_), SetAttribute::Set(_)) => {
+                std::cmp::Ordering::Greater
+            }
+            (SetAttribute::Unknown(id1), SetAttribute::Unknown(id2)) => {
+                id1.as_ref().cmp(id2.as_ref())
+            }
+        }
+    }
+}
+
+impl PartialOrd for SetAttribute {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl From<Id> for SetAttribute {
+    fn from(v: Id) -> Self {
+        Self::Unknown(v)
+    }
+}
+
+impl From<SetAttr> for SetAttribute {
+    fn from(v: SetAttr) -> Self {
+        Self::Set(v)
+    }
+}
+
+impl std::fmt::Display for SetAttribute {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SetAttribute::Set(set_attr) => set_attr.fmt(f),
+            SetAttribute::Unknown(id) => id.fmt(f),
+        }
+    }
+}
+
+impl FromStr for SetAttribute {
+    type Err = Error;
+    fn from_str(s: &str) -> CalyxResult<Self> {
+        if let Ok(s) = SetAttr::from_str(s) {
+            Ok(SetAttribute::Set(s))
+        } else {
+            // Reject attributes that all caps since those are reserved for internal attributes
+            if s.to_uppercase() == s {
+                return Err(Error::misc(format!("Invalid attribute: {}. All caps attributes are reserved for internal use.", s)));
+            }
+            Ok(SetAttribute::Unknown(s.into()))
+        }
+    }
+}
+
 #[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
 /// Defines the known attributes that can be attached to IR nodes.
@@ -197,6 +279,11 @@ impl FromStr for Attribute {
             if DEPRECATED_ATTRIBUTES.contains(&s) {
                 log::warn!("The attribute @{s} is deprecated and will be ignored by the compiler.");
             }
+
+            if let Ok(SetAttribute::Set(_)) = SetAttribute::from_str(s) {
+                log::warn!("Set attribute {s} incorrectly written as a standard attribute, i.e. '@{s}(..)' or '\"{s}\" = ..'. This will be ignored by the compiler. Instead write '@{s}{{..}}' or '\"{s}\" = {{..}}'.");
+            }
+
             // Reject attributes that all caps since those are reserved for internal attributes
             if s.to_uppercase() == s {
                 return Err(Error::misc(format!("Invalid attribute: {}. All caps attributes are reserved for internal use.", s)));