fix: parse workspace hints sections such that expressions are not supported.

wdl-analysis/src/scope/v1.rs

@@ -18,13 +18,13 @@ use wdl_ast::v1::CommandSection;
 use wdl_ast::v1::Decl;
 use wdl_ast::v1::DocumentItem;
 use wdl_ast::v1::Expr;
-use wdl_ast::v1::HintsSection;
 use wdl_ast::v1::ImportStatement;
 use wdl_ast::v1::NameRef;
 use wdl_ast::v1::RequirementsSection;
 use wdl_ast::v1::RuntimeSection;
 use wdl_ast::v1::StructDefinition;
 use wdl_ast::v1::TaskDefinition;
+use wdl_ast::v1::TaskHintsSection;
 use wdl_ast::v1::TaskItem;
 use wdl_ast::v1::WorkflowDefinition;
 use wdl_ast::v1::WorkflowItem;
@@ -1039,7 +1039,7 @@ fn type_check_task(
             /// The scope to use for evaluating the hints section.
             scope: ScopeIndex,
             /// The hints section.
-            section: HintsSection,
+            section: TaskHintsSection,
         },
     }
 

wdl-ast/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Fixed
+
+* Split hint section representation into `TaskHintsSection` and
+  `WorkflowHintsSection` as the latter no longer supports expressions ([#176](https://github.com/stjude-rust-labs/wdl/pull/176))
+
+
 ## 0.7.1 - 09-16-2024
 
 ### Fixed

wdl-ast/src/v1/task.rs

@@ -64,7 +64,7 @@ impl TaskDefinition {
     }
 
     /// Gets the hints section of the task.
-    pub fn hints(&self) -> Option<HintsSection> {
+    pub fn hints(&self) -> Option<TaskHintsSection> {
         child(&self.0)
     }
 
@@ -126,7 +126,7 @@ pub enum TaskItem {
     /// The item is a requirements section.
     Requirements(RequirementsSection),
     /// The item is a hints section.
-    Hints(HintsSection),
+    Hints(TaskHintsSection),
     /// The item is a runtime section.
     Runtime(RuntimeSection),
     /// The item is a metadata section.
@@ -150,7 +150,7 @@ impl AstNode for TaskItem {
                 | SyntaxKind::OutputSectionNode
                 | SyntaxKind::CommandSectionNode
                 | SyntaxKind::RequirementsSectionNode
-                | SyntaxKind::HintsSectionNode
+                | SyntaxKind::TaskHintsSectionNode
                 | SyntaxKind::RuntimeSectionNode
                 | SyntaxKind::MetadataSectionNode
                 | SyntaxKind::ParameterMetadataSectionNode
@@ -169,7 +169,7 @@ impl AstNode for TaskItem {
             SyntaxKind::RequirementsSectionNode => {
                 Some(Self::Requirements(RequirementsSection(syntax)))
             }
-            SyntaxKind::HintsSectionNode => Some(Self::Hints(HintsSection(syntax))),
+            SyntaxKind::TaskHintsSectionNode => Some(Self::Hints(TaskHintsSection(syntax))),
             SyntaxKind::RuntimeSectionNode => Some(Self::Runtime(RuntimeSection(syntax))),
             SyntaxKind::MetadataSectionNode => Some(Self::Metadata(MetadataSection(syntax))),
             SyntaxKind::ParameterMetadataSectionNode => {
@@ -606,37 +606,37 @@ impl AstNode for RequirementsItem {
 
 /// Represents a hints section in a task definition.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct HintsSection(pub(crate) SyntaxNode);
+pub struct TaskHintsSection(pub(crate) SyntaxNode);
 
-impl HintsSection {
+impl TaskHintsSection {
     /// Gets the items in the hints section.
-    pub fn items(&self) -> AstChildren<HintsItem> {
+    pub fn items(&self) -> AstChildren<TaskHintsItem> {
         children(&self.0)
     }
 
     /// Gets the parent of the hints section.
-    pub fn parent(&self) -> SectionParent {
-        SectionParent::cast(self.0.parent().expect("should have a parent"))
+    pub fn parent(&self) -> TaskDefinition {
+        TaskDefinition::cast(self.0.parent().expect("should have a parent"))
             .expect("parent should cast")
     }
 }
 
-impl AstNode for HintsSection {
+impl AstNode for TaskHintsSection {
     type Language = WorkflowDescriptionLanguage;
 
     fn can_cast(kind: SyntaxKind) -> bool
     where
         Self: Sized,
     {
-        kind == SyntaxKind::HintsSectionNode
+        kind == SyntaxKind::TaskHintsSectionNode
     }
 
     fn cast(syntax: SyntaxNode) -> Option<Self>
     where
         Self: Sized,
     {
         match syntax.kind() {
-            SyntaxKind::HintsSectionNode => Some(Self(syntax)),
+            SyntaxKind::TaskHintsSectionNode => Some(Self(syntax)),
             _ => None,
         }
     }
@@ -646,11 +646,11 @@ impl AstNode for HintsSection {
     }
 }
 
-/// Represents an item in a hints section.
+/// Represents an item in a task hints section.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct HintsItem(SyntaxNode);
+pub struct TaskHintsItem(SyntaxNode);
 
-impl HintsItem {
+impl TaskHintsItem {
     /// Gets the name of the hints item.
     pub fn name(&self) -> Ident {
         token(&self.0).expect("expected an item name")
@@ -662,22 +662,22 @@ impl HintsItem {
     }
 }
 
-impl AstNode for HintsItem {
+impl AstNode for TaskHintsItem {
     type Language = WorkflowDescriptionLanguage;
 
     fn can_cast(kind: SyntaxKind) -> bool
     where
         Self: Sized,
     {
-        kind == SyntaxKind::HintsItemNode
+        kind == SyntaxKind::TaskHintsItemNode
     }
 
     fn cast(syntax: SyntaxNode) -> Option<Self>
     where
         Self: Sized,
     {
         match syntax.kind() {
-            SyntaxKind::HintsItemNode => Some(Self(syntax)),
+            SyntaxKind::TaskHintsItemNode => Some(Self(syntax)),
             _ => None,
         }
     }
@@ -1292,7 +1292,7 @@ task test {
 
         // Task hints
         let hints = tasks[0].hints().expect("should have a hints section");
-        assert_eq!(hints.parent().unwrap_task().name().as_str(), "test");
+        assert_eq!(hints.parent().name().as_str(), "test");
         let items: Vec<_> = hints.items().collect();
         assert_eq!(items.len(), 1);
         assert_eq!(items[0].name().as_str(), "foo");
@@ -1456,11 +1456,11 @@ task test {
                 }
             }
 
-            fn hints_section(
+            fn task_hints_section(
                 &mut self,
                 _: &mut Self::State,
                 reason: VisitReason,
-                _: &HintsSection,
+                _: &TaskHintsSection,
             ) {
                 if reason == VisitReason::Enter {
                     self.hints += 1;