Remove annotations from non-code-meta and store them in nodes (#5360)

Signed-off-by: Nick Cameron <nrc@ncameron.org>

src/lang/KclSingleton.ts

@@ -60,7 +60,8 @@ export class KclManager {
       nonCodeNodes: {},
       startNodes: [],
     },
-    trivia: [],
+    innerAttrs: [],
+    outerAttrs: [],
   }
   private _execState: ExecState = emptyExecState()
   private _variables: VariableMap = {}
@@ -255,7 +256,8 @@ export class KclManager {
         nonCodeNodes: {},
         startNodes: [],
       },
-      trivia: [],
+      innerAttrs: [],
+      outerAttrs: [],
     }
   }
 

src/lang/modifyAst.test.ts

@@ -134,7 +134,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -142,7 +142,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -150,7 +150,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -158,7 +158,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -166,7 +166,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -174,7 +174,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -182,7 +182,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -190,7 +190,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
         {
           type: 'Identifier',
@@ -198,7 +198,7 @@ describe('Testing findUniqueName', () => {
           start: 0,
           end: 0,
           moduleId: 0,
-          trivia: [],
+          outerAttrs: [],
         },
       ] satisfies Node<Identifier>[]),
       'yo',
@@ -217,7 +217,8 @@ describe('Testing addSketchTo', () => {
         end: 0,
         moduleId: 0,
         nonCodeMeta: { nonCodeNodes: {}, startNodes: [] },
-        trivia: [],
+        innerAttrs: [],
+        outerAttrs: [],
       },
       'yz'
     )

src/lang/modifyAst.ts

@@ -278,7 +278,7 @@ export function mutateObjExpProp(
         start: 0,
         end: 0,
         moduleId: 0,
-        trivia: [],
+        outerAttrs: [],
       })
     }
   }
@@ -891,7 +891,7 @@ export function createLiteral(value: LiteralValue | number): Node<Literal> {
     moduleId: 0,
     value,
     raw,
-    trivia: [],
+    outerAttrs: [],
   }
 }
 
@@ -901,7 +901,7 @@ export function createTagDeclarator(value: string): Node<TagDeclarator> {
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     value,
   }
@@ -913,7 +913,7 @@ export function createIdentifier(name: string): Node<Identifier> {
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     name,
   }
@@ -925,7 +925,7 @@ export function createPipeSubstitution(): Node<PipeSubstitution> {
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
   }
 }
 
@@ -938,13 +938,13 @@ export function createCallExpressionStdLib(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
     callee: {
       type: 'Identifier',
       start: 0,
       end: 0,
       moduleId: 0,
-      trivia: [],
+      outerAttrs: [],
 
       name,
     },
@@ -962,13 +962,13 @@ export function createCallExpressionStdLibKw(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
     callee: {
       type: 'Identifier',
       start: 0,
       end: 0,
       moduleId: 0,
-      trivia: [],
+      outerAttrs: [],
 
       name,
     },
@@ -986,13 +986,13 @@ export function createCallExpression(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
     callee: {
       type: 'Identifier',
       start: 0,
       end: 0,
       moduleId: 0,
-      trivia: [],
+      outerAttrs: [],
 
       name,
     },
@@ -1008,7 +1008,7 @@ export function createArrayExpression(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     nonCodeMeta: nonCodeMetaEmpty(),
     elements,
@@ -1023,7 +1023,7 @@ export function createPipeExpression(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     body,
     nonCodeMeta: nonCodeMetaEmpty(),
@@ -1041,14 +1041,14 @@ export function createVariableDeclaration(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     declaration: {
       type: 'VariableDeclarator',
       start: 0,
       end: 0,
       moduleId: 0,
-      trivia: [],
+      outerAttrs: [],
 
       id: createIdentifier(varName),
       init,
@@ -1066,7 +1066,7 @@ export function createObjectExpression(properties: {
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     nonCodeMeta: nonCodeMetaEmpty(),
     properties: Object.entries(properties).map(([key, value]) => ({
@@ -1074,7 +1074,7 @@ export function createObjectExpression(properties: {
       start: 0,
       end: 0,
       moduleId: 0,
-      trivia: [],
+      outerAttrs: [],
       key: createIdentifier(key),
 
       value,
@@ -1091,7 +1091,7 @@ export function createUnaryExpression(
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     operator,
     argument,
@@ -1108,7 +1108,7 @@ export function createBinaryExpression([left, operator, right]: [
     start: 0,
     end: 0,
     moduleId: 0,
-    trivia: [],
+    outerAttrs: [],
 
     operator,
     left,

src/lang/std/sketch.ts

@@ -1945,7 +1945,8 @@ export const updateStartProfileAtArgs: SketchLineHelper['updateArgs'] = ({
           startNodes: [],
           nonCodeNodes: [],
         },
-        trivia: [],
+        innerAttrs: [],
+        outerAttrs: [],
       },
       pathToNode,
     }
@@ -2527,7 +2528,7 @@ function addTagKw(): addTagFn {
         start: callExpr.node.start,
         end: callExpr.node.end,
         moduleId: callExpr.node.moduleId,
-        trivia: callExpr.node.trivia,
+        outerAttrs: callExpr.node.outerAttrs,
       })
     }
 

src/wasm-lib/kcl/src/execution/annotations.rs

@@ -5,14 +5,18 @@ use kittycad_modeling_cmds::coord::{System, KITTYCAD, OPENGL, VULKAN};
 use crate::{
     errors::KclErrorDetails,
     execution::kcl_value::{UnitAngle, UnitLen},
-    parsing::ast::types::{Expr, Node, NonCodeValue, ObjectProperty},
+    parsing::ast::types::{Annotation, Expr, Node, ObjectProperty},
     KclError, SourceRange,
 };
 
+/// Annotations which should cause re-execution if they change.
+pub(super) const SIGNIFICANT_ATTRS: [&str; 2] = [SETTINGS, NO_PRELUDE];
+
 pub(crate) const SETTINGS: &str = "settings";
 pub(crate) const SETTINGS_UNIT_LENGTH: &str = "defaultLengthUnit";
 pub(crate) const SETTINGS_UNIT_ANGLE: &str = "defaultAngleUnit";
 pub(super) const NO_PRELUDE: &str = "no_prelude";
+
 pub(super) const IMPORT_FORMAT: &str = "format";
 pub(super) const IMPORT_FORMAT_VALUES: [&str; 9] = ["fbx", "gltf", "glb", "obj", "ply", "sldprt", "stp", "step", "stl"];
 pub(super) const IMPORT_COORDS: &str = "coords";
@@ -25,35 +29,24 @@ pub(super) enum AnnotationScope {
     Module,
 }
 
-pub(super) fn expect_properties<'a>(
+pub(super) fn is_significant(attr: &&Node<Annotation>) -> bool {
-    for_key: &'static str,
+    match attr.name() {
-    annotation: &'a NonCodeValue,
+        Some(name) => SIGNIFICANT_ATTRS.contains(&name),
-    source_range: SourceRange,
+        None => true,
-) -> Result<&'a [Node<ObjectProperty>], KclError> {
-    match annotation {
-        NonCodeValue::Annotation { name, properties } => {
-            assert_eq!(name.as_ref().unwrap().name, for_key);
-            Ok(&**properties.as_ref().ok_or_else(|| {
-                KclError::Semantic(KclErrorDetails {
-                    message: format!("Empty `{for_key}` annotation"),
-                    source_ranges: vec![source_range],
-                })
-            })?)
-        }
-        _ => unreachable!(),
     }
 }
 
-pub(super) fn unnamed_properties<'a>(
+pub(super) fn expect_properties<'a>(
-    annotations: impl Iterator<Item = &'a NonCodeValue>,
+    for_key: &'static str,
-) -> Option<&'a [Node<ObjectProperty>]> {
+    annotation: &'a Node<Annotation>,
-    for annotation in annotations {
+) -> Result<&'a [Node<ObjectProperty>], KclError> {
-        if let NonCodeValue::Annotation { name: None, properties } = annotation {
+    assert_eq!(annotation.name().unwrap(), for_key);
-            return properties.as_deref();
+    Ok(&**annotation.properties.as_ref().ok_or_else(|| {
-        }
+        KclError::Semantic(KclErrorDetails {
-    }
+            message: format!("Empty `{for_key}` annotation"),
-
+            source_ranges: vec![annotation.as_source_range()],
-    None
+        })
+    })?)
 }
 
 pub(super) fn expect_ident(expr: &Expr) -> Result<&str, KclError> {

src/wasm-lib/kcl/src/execution/cache.rs

@@ -6,8 +6,8 @@ use itertools::{EitherOrBoth, Itertools};
 use tokio::sync::RwLock;
 
 use crate::{
-    execution::{memory::ProgramMemory, ExecState, ExecutorSettings},
+    execution::{annotations, memory::ProgramMemory, ExecState, ExecutorSettings},
-    parsing::ast::types::{Node, NonCodeValue, Program},
+    parsing::ast::types::{Annotation, Node, Program},
     walk::Node as WalkNode,
 };
 
@@ -91,7 +91,7 @@ pub(super) enum CacheResult {
 /// Returns `None` when there are no changes to the program, i.e. it is
 /// fully cached.
 pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInformation<'_>) -> CacheResult {
-    let mut try_reapply_settings = false;
+    let mut reapply_settings = false;
 
     // If the settings are different we might need to bust the cache.
     // We specifically do this before checking if they are the exact same.
@@ -107,13 +107,13 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
 
         // If anything else is different we may not need to re-execute, but rather just
         // run the settings again.
-        try_reapply_settings = true;
+        reapply_settings = true;
     }
 
     // If the ASTs are the EXACT same we return None.
     // We don't even need to waste time computing the digests.
     if old.ast == new.ast {
-        return CacheResult::NoAction(try_reapply_settings);
+        return CacheResult::NoAction(reapply_settings);
     }
 
     // We have to clone just because the digests are stored inline :-(
@@ -127,23 +127,27 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
 
     // Check if the digest is the same.
     if old_ast.digest == new_ast.digest {
-        return CacheResult::NoAction(try_reapply_settings);
+        return CacheResult::NoAction(reapply_settings);
     }
 
     // Check if the annotations are different.
-    if !old_ast.annotations().zip_longest(new_ast.annotations()).all(|pair| {
+    if !old_ast
+        .inner_attrs
+        .iter()
+        .filter(annotations::is_significant)
+        .zip_longest(new_ast.inner_attrs.iter().filter(annotations::is_significant))
+        .all(|pair| {
             match pair {
                 EitherOrBoth::Both(old, new) => {
                     // Compare annotations, ignoring source ranges.  Digests must
                     // have been computed before this.
-                match (&old.value, &new.value) {
+                    let Annotation { name, properties, .. } = &old.inner;
-                    (
+                    let Annotation {
-                        NonCodeValue::Annotation { name, properties },
-                        NonCodeValue::Annotation {
                         name: new_name,
                         properties: new_properties,
-                        },
+                        ..
-                    ) => {
+                    } = &new.inner;
+
                     name.as_ref().map(|n| n.digest) == new_name.as_ref().map(|n| n.digest)
                         && properties
                             .as_ref()
@@ -154,10 +158,8 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
                 }
                 _ => false,
             }
-            }
+        })
-            _ => false,
+    {
-        }
-    }) {
         // If any of the annotations are different at the beginning of the
         // program, it's likely the settings, and we have to bust the cache and
         // re-execute the whole thing.
@@ -169,12 +171,7 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
     }
 
     // Check if the changes were only to Non-code areas, like comments or whitespace.
-    let (clear_scene, program) = generate_changed_program(old_ast, new_ast);
+    generate_changed_program(old_ast, new_ast, reapply_settings)
-    CacheResult::ReExecute {
-        clear_scene,
-        reapply_settings: try_reapply_settings,
-        program,
-    }
 }
 
 /// Force-generate a new CacheResult, even if one shouldn't be made. The
@@ -183,7 +180,7 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
 /// how we construct a new [CacheResult].
 ///
 /// Digests *must* be computed before calling this.
-fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>) -> (bool, Node<Program>) {
+fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>, reapply_settings: bool) -> CacheResult {
     if !old_ast.body.iter().zip(new_ast.body.iter()).all(|(old, new)| {
         let old_node: WalkNode = old.into();
         let new_node: WalkNode = new.into();
@@ -194,7 +191,11 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>)
         // means a single insertion or deletion will result in a cache
         // bust.
 
-        return (true, new_ast);
+        return CacheResult::ReExecute {
+            clear_scene: true,
+            reapply_settings,
+            program: new_ast,
+        };
     }
 
     // otherwise the overlapping section of the ast bodies matches.
@@ -210,7 +211,11 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>)
             // supporting that.
 
             // Cache bust time.
-            (true, new_ast)
+            CacheResult::ReExecute {
+                clear_scene: true,
+                reapply_settings,
+                program: new_ast,
+            }
         }
         std::cmp::Ordering::Greater => {
             // the new AST is longer than the old AST, which means
@@ -222,7 +227,11 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>)
 
             new_ast.body = new_ast.body[old_ast.body.len()..].to_owned();
 
-            (false, new_ast)
+            CacheResult::ReExecute {
+                clear_scene: false,
+                reapply_settings,
+                program: new_ast,
+            }
         }
         std::cmp::Ordering::Equal => {
             // currently unreachable, but let's pretend like the code
@@ -234,9 +243,7 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>)
             // so but i think many things. This def needs to change
             // when the code above changes.
 
-            new_ast.body = vec![];
+            CacheResult::NoAction(reapply_settings)
-
-            (false, new_ast)
         }
     }
 }
@@ -368,8 +375,10 @@ shell(firstSketch, faces = ['end'], thickness = 0.25)"#;
     }
 
     #[tokio::test(flavor = "multi_thread")]
-    async fn test_get_changed_program_same_code_changed_code_comments() {
+    async fn test_get_changed_program_same_code_changed_code_comments_attrs() {
-        let old = r#" // Removed the end face for the extrusion.
+        let old = r#"@foo(whatever = whatever)
+@bar
+// Removed the end face for the extrusion.
 firstSketch = startSketchOn('XY')
   |> startProfileAt([-12, 12], %)
   |> line(end = [24, 0])
@@ -381,7 +390,9 @@ firstSketch = startSketchOn('XY')
 // Remove the end face for the extrusion.
 shell(firstSketch, faces = ['end'], thickness = 0.25) "#;
 
-        let new = r#"// Remove the end face for the extrusion.
+        let new = r#"@foo(whatever = 42)
+@baz
+// Remove the end face for the extrusion.
 firstSketch = startSketchOn('XY')
   |> startProfileAt([-12, 12], %)
   |> line(end = [24, 0])

src/wasm-lib/kcl/src/execution/exec_ast.rs

@@ -17,9 +17,9 @@ use crate::{
     },
     modules::{ModuleId, ModulePath, ModuleRepr},
     parsing::ast::types::{
-        ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem, CallExpression,
+        Annotation, ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem,
-        CallExpressionKw, Expr, FunctionExpression, IfExpression, ImportPath, ImportSelector, ItemVisibility,
+        CallExpression, CallExpressionKw, Expr, FunctionExpression, IfExpression, ImportPath, ImportSelector,
-        LiteralIdentifier, LiteralValue, MemberExpression, MemberObject, Node, NodeRef, NonCodeNode, NonCodeValue,
+        ItemVisibility, LiteralIdentifier, LiteralValue, MemberExpression, MemberObject, Node, NodeRef,
         ObjectExpression, PipeExpression, Program, TagDeclarator, UnaryExpression, UnaryOperator,
     },
     source_range::SourceRange,
@@ -37,37 +37,36 @@ enum StatementKind<'a> {
 impl ExecutorContext {
     async fn handle_annotations(
         &self,
-        annotations: impl Iterator<Item = (&NonCodeValue, SourceRange)>,
+        annotations: impl Iterator<Item = &Node<Annotation>>,
         scope: annotations::AnnotationScope,
         exec_state: &mut ExecState,
     ) -> Result<bool, KclError> {
         let mut no_prelude = false;
-        for (annotation, source_range) in annotations {
+        for annotation in annotations {
-            if annotation.annotation_name() == Some(annotations::SETTINGS) {
+            if annotation.name() == Some(annotations::SETTINGS) {
                 if scope == annotations::AnnotationScope::Module {
                     let old_units = exec_state.length_unit();
-                    exec_state
+                    exec_state.mod_local.settings.update_from_annotation(annotation)?;
-                        .mod_local
-                        .settings
-                        .update_from_annotation(annotation, source_range)?;
                     let new_units = exec_state.length_unit();
                     if !self.engine.execution_kind().is_isolated() && old_units != new_units {
-                        self.engine.set_units(new_units.into(), source_range).await?;
+                        self.engine
+                            .set_units(new_units.into(), annotation.as_source_range())
+                            .await?;
                     }
                 } else {
                     return Err(KclError::Semantic(KclErrorDetails {
                         message: "Settings can only be modified at the top level scope of a file".to_owned(),
-                        source_ranges: vec![source_range],
+                        source_ranges: vec![annotation.as_source_range()],
                     }));
                 }
             }
-            if annotation.annotation_name() == Some(annotations::NO_PRELUDE) {
+            if annotation.name() == Some(annotations::NO_PRELUDE) {
                 if scope == annotations::AnnotationScope::Module {
                     no_prelude = true;
                 } else {
                     return Err(KclError::Semantic(KclErrorDetails {
                         message: "Prelude can only be skipped at the top level scope of a file".to_owned(),
-                        source_ranges: vec![source_range],
+                        source_ranges: vec![annotation.as_source_range()],
                     }));
                 }
             }
@@ -87,11 +86,7 @@ impl ExecutorContext {
         if body_type == BodyType::Root {
             let _no_prelude = self
                 .handle_annotations(
-                    program
+                    program.inner_attrs.iter(),
-                        .non_code_meta
-                        .start_nodes
-                        .iter()
-                        .filter_map(|n| n.annotation().map(|result| (result, n.as_source_range()))),
                     annotations::AnnotationScope::Module,
                     exec_state,
                 )
@@ -100,7 +95,7 @@ impl ExecutorContext {
 
         let mut last_expr = None;
         // Iterate over the body of the program.
-        for (i, statement) in program.body.iter().enumerate() {
+        for statement in &program.body {
             match statement {
                 BodyItem::ImportStatement(import_stmt) => {
                     if body_type != BodyType::Root {
@@ -111,9 +106,9 @@ impl ExecutorContext {
                     }
 
                     let source_range = SourceRange::from(import_stmt);
-                    let meta_nodes = program.non_code_meta.get(i);
+                    let attrs = &import_stmt.outer_attrs;
                     let module_id = self
-                        .open_module(&import_stmt.path, meta_nodes, exec_state, source_range)
+                        .open_module(&import_stmt.path, attrs, exec_state, source_range)
                         .await?;
 
                     match &import_stmt.selector {
@@ -209,7 +204,7 @@ impl ExecutorContext {
                     let source_range = SourceRange::from(&variable_declaration.declaration.init);
                     let metadata = Metadata { source_range };
 
-                    let _meta_nodes = program.non_code_meta.get(i);
+                    let _annotations = &variable_declaration.outer_attrs;
 
                     let memory_item = self
                         .execute_expr(
@@ -279,7 +274,7 @@ impl ExecutorContext {
     async fn open_module(
         &self,
         path: &ImportPath,
-        non_code_meta: &[Node<NonCodeNode>],
+        attrs: &[Node<Annotation>],
         exec_state: &mut ExecState,
         source_range: SourceRange,
     ) -> Result<ModuleId, KclError> {
@@ -307,7 +302,7 @@ impl ExecutorContext {
 
                 let id = exec_state.next_module_id();
                 let path = resolved_path.expect_path();
-                let format = super::import::format_from_annotations(non_code_meta, path, source_range)?;
+                let format = super::import::format_from_annotations(attrs, path, source_range)?;
                 let geom = super::import::import_foreign(path, format, exec_state, self, source_range).await?;
                 exec_state.add_module(id, resolved_path, ModuleRepr::Foreign(geom));
                 Ok(id)
@@ -1838,18 +1833,7 @@ mod test {
             // Run each test.
             let func_expr = &Node::no_src(FunctionExpression {
                 params,
-                body: Node {
+                body: crate::parsing::ast::types::Program::empty(),
-                    inner: crate::parsing::ast::types::Program {
-                        body: Vec::new(),
-                        non_code_meta: Default::default(),
-                        shebang: None,
-                        digest: None,
-                    },
-                    start: 0,
-                    end: 0,
-                    module_id: ModuleId::default(),
-                    trivia: Vec::new(),
-                },
                 return_type: None,
                 digest: None,
             });

src/wasm-lib/kcl/src/execution/import.rs

@@ -19,7 +19,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{annotations, kcl_value::UnitLen, ExecState, ExecutorContext, ImportedGeometry},
     fs::FileSystem,
-    parsing::ast::types::{Node, NonCodeNode},
+    parsing::ast::types::{Annotation, Node},
     source_range::SourceRange,
 };
 
@@ -155,16 +155,18 @@ pub async fn import_foreign(
 }
 
 pub(super) fn format_from_annotations(
-    non_code_meta: &[Node<NonCodeNode>],
+    annotations: &[Node<Annotation>],
     path: &Path,
     import_source_range: SourceRange,
 ) -> Result<Option<InputFormat>, KclError> {
-    let Some(props) = annotations::unnamed_properties(non_code_meta.iter().map(|n| &n.value)) else {
+    if annotations.is_empty() {
         return Ok(None);
-    };
+    }
+
+    let props = annotations.iter().flat_map(|a| a.properties.as_deref().unwrap_or(&[]));
 
     let mut result = None;
-    for p in props {
+    for p in props.clone() {
         if p.key.name == annotations::IMPORT_FORMAT {
             result = Some(
                 get_import_format_from_extension(annotations::expect_ident(&p.value)?).map_err(|_| {
@@ -422,8 +424,8 @@ mod test {
         // no format, no options
         let text = "@()\nimport '../foo.gltf' as foo";
         let parsed = crate::Program::parse_no_errs(text).unwrap().ast;
-        let non_code_meta = parsed.non_code_meta.get(0);
+        let attrs = parsed.body[0].get_attrs();
-        let fmt = format_from_annotations(non_code_meta, Path::new("../foo.gltf"), SourceRange::default())
+        let fmt = format_from_annotations(attrs, Path::new("../foo.gltf"), SourceRange::default())
             .unwrap()
             .unwrap();
         assert_eq!(
@@ -434,8 +436,8 @@ mod test {
         // format, no options
         let text = "@(format = gltf)\nimport '../foo.txt' as foo";
         let parsed = crate::Program::parse_no_errs(text).unwrap().ast;
-        let non_code_meta = parsed.non_code_meta.get(0);
+        let attrs = parsed.body[0].get_attrs();
-        let fmt = format_from_annotations(non_code_meta, Path::new("../foo.txt"), SourceRange::default())
+        let fmt = format_from_annotations(attrs, Path::new("../foo.txt"), SourceRange::default())
             .unwrap()
             .unwrap();
         assert_eq!(
@@ -444,7 +446,7 @@ mod test {
         );
 
         // format, no extension (wouldn't parse but might some day)
-        let fmt = format_from_annotations(non_code_meta, Path::new("../foo"), SourceRange::default())
+        let fmt = format_from_annotations(attrs, Path::new("../foo"), SourceRange::default())
             .unwrap()
             .unwrap();
         assert_eq!(
@@ -455,8 +457,8 @@ mod test {
         // format, options
         let text = "@(format = obj, coords = vulkan, lengthUnit = ft)\nimport '../foo.txt' as foo";
         let parsed = crate::Program::parse_no_errs(text).unwrap().ast;
-        let non_code_meta = parsed.non_code_meta.get(0);
+        let attrs = parsed.body[0].get_attrs();
-        let fmt = format_from_annotations(non_code_meta, Path::new("../foo.txt"), SourceRange::default())
+        let fmt = format_from_annotations(attrs, Path::new("../foo.txt"), SourceRange::default())
             .unwrap()
             .unwrap();
         assert_eq!(
@@ -470,8 +472,8 @@ mod test {
         // no format, options
         let text = "@(coords = vulkan, lengthUnit = ft)\nimport '../foo.obj' as foo";
         let parsed = crate::Program::parse_no_errs(text).unwrap().ast;
-        let non_code_meta = parsed.non_code_meta.get(0);
+        let attrs = parsed.body[0].get_attrs();
-        let fmt = format_from_annotations(non_code_meta, Path::new("../foo.obj"), SourceRange::default())
+        let fmt = format_from_annotations(attrs, Path::new("../foo.obj"), SourceRange::default())
             .unwrap()
             .unwrap();
         assert_eq!(
@@ -523,8 +525,8 @@ mod test {
     #[track_caller]
     fn assert_annotation_error(src: &str, path: &str, expected: &str) {
         let parsed = crate::Program::parse_no_errs(src).unwrap().ast;
-        let non_code_meta = parsed.non_code_meta.get(0);
+        let attrs = parsed.body[0].get_attrs();
-        let err = format_from_annotations(non_code_meta, Path::new(path), SourceRange::default()).unwrap_err();
+        let err = format_from_annotations(attrs, Path::new(path), SourceRange::default()).unwrap_err();
         assert!(
             err.message().contains(expected),
             "Expected: `{expected}`, found `{}`",

src/wasm-lib/kcl/src/execution/state.rs

@@ -12,7 +12,7 @@ use crate::{
         ExecOutcome, ExecutorSettings, KclValue, Operation, UnitAngle, UnitLen,
     },
     modules::{ModuleId, ModuleInfo, ModuleLoader, ModulePath, ModuleRepr},
-    parsing::ast::types::NonCodeValue,
+    parsing::ast::types::Annotation,
     source_range::SourceRange,
 };
 
@@ -236,21 +236,20 @@ pub struct MetaSettings {
 impl MetaSettings {
     pub(crate) fn update_from_annotation(
         &mut self,
-        annotation: &NonCodeValue,
+        annotation: &crate::parsing::ast::types::Node<Annotation>,
-        source_range: SourceRange,
     ) -> Result<(), KclError> {
-        let properties = annotations::expect_properties(annotations::SETTINGS, annotation, source_range)?;
+        let properties = annotations::expect_properties(annotations::SETTINGS, annotation)?;
 
         for p in properties {
             match &*p.inner.key.name {
                 annotations::SETTINGS_UNIT_LENGTH => {
                     let value = annotations::expect_ident(&p.inner.value)?;
-                    let value = kcl_value::UnitLen::from_str(value, source_range)?;
+                    let value = kcl_value::UnitLen::from_str(value, annotation.as_source_range())?;
                     self.default_length_units = value;
                 }
                 annotations::SETTINGS_UNIT_ANGLE => {
                     let value = annotations::expect_ident(&p.inner.value)?;
-                    let value = kcl_value::UnitAngle::from_str(value, source_range)?;
+                    let value = kcl_value::UnitAngle::from_str(value, annotation.as_source_range())?;
                     self.default_angle_units = value;
                 }
                 name => {
@@ -260,7 +259,7 @@ impl MetaSettings {
                             annotations::SETTINGS_UNIT_LENGTH,
                             annotations::SETTINGS_UNIT_ANGLE
                         ),
-                        source_ranges: vec![source_range],
+                        source_ranges: vec![annotation.as_source_range()],
                     }))
                 }
             }

src/wasm-lib/kcl/src/parsing/ast/digest.rs

@@ -1,13 +1,10 @@
 use sha2::{Digest as DigestTrait, Sha256};
 
-use super::types::{
+use super::types::{DefaultParamVal, ItemVisibility, LabelledExpression, LiteralValue, VariableKind};
-    DefaultParamVal, ItemVisibility, LabelledExpression, LiteralValue, NonCodeMeta, NonCodeNode, NonCodeValue,
-    VariableKind,
-};
 use crate::parsing::ast::types::{
-    ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryPart, BodyItem, CallExpression, CallExpressionKw,
+    Annotation, ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryPart, BodyItem, CallExpression,
-    ElseIf, Expr, ExpressionStatement, FnArgType, FunctionExpression, Identifier, IfExpression, ImportItem,
+    CallExpressionKw, ElseIf, Expr, ExpressionStatement, FnArgType, FunctionExpression, Identifier, IfExpression,
-    ImportSelector, ImportStatement, KclNone, Literal, LiteralIdentifier, MemberExpression, MemberObject,
+    ImportItem, ImportSelector, ImportStatement, KclNone, Literal, LiteralIdentifier, MemberExpression, MemberObject,
     ObjectExpression, ObjectProperty, Parameter, PipeExpression, PipeSubstitution, Program, ReturnStatement,
     TagDeclarator, UnaryExpression, VariableDeclaration, VariableDeclarator,
 };
@@ -82,49 +79,22 @@ impl Program {
         for body_item in slf.body.iter_mut() {
             hasher.update(body_item.compute_digest());
         }
-        // This contains settings annotations.
+        for attr in &mut slf.inner_attrs {
-        hasher.update(slf.non_code_meta.compute_digest());
+            hasher.update(attr.compute_digest());
+        }
         if let Some(shebang) = &slf.shebang {
             hasher.update(&shebang.inner.content);
         }
     });
 }
 
-impl NonCodeMeta {
+impl Annotation {
-    compute_digest!(|slf, hasher| {
-        for non_code_node in slf.start_nodes.iter_mut() {
-            hasher.update(non_code_node.compute_digest());
-        }
-        for (_, non_code_nodes) in slf.non_code_nodes.iter_mut() {
-            for non_code_node in non_code_nodes.iter_mut() {
-                hasher.update(non_code_node.compute_digest());
-            }
-        }
-    });
-}
-
-impl NonCodeNode {
-    compute_digest!(|slf, hasher| {
-        hasher.update(slf.value.compute_digest());
-    });
-}
-
-impl NonCodeValue {
     pub fn compute_digest(&mut self) -> Digest {
         let mut hasher = Sha256::new();
-        match self {
+        if let Some(name) = &mut self.name {
-            NonCodeValue::InlineComment { .. } => {}
-            NonCodeValue::BlockComment { .. } => {}
-            NonCodeValue::NewLineBlockComment { .. } => {}
-            NonCodeValue::NewLine => {}
-            NonCodeValue::Annotation {
-                ref mut name,
-                properties,
-            } => {
-                if let Some(name) = name {
             hasher.update(name.compute_digest());
         }
-                if let Some(properties) = properties {
+        if let Some(properties) = &mut self.properties {
             hasher.update(properties.len().to_ne_bytes());
             for property in properties.iter_mut() {
                 hasher.update(property.compute_digest());
@@ -132,20 +102,24 @@ impl NonCodeValue {
         } else {
             hasher.update("no_properties");
         }
-            }
-        }
         hasher.finalize().into()
     }
 }
 
 impl BodyItem {
     pub fn compute_digest(&mut self) -> Digest {
-        match self {
+        let mut hasher = Sha256::new();
+        hasher.update(match self {
             BodyItem::ImportStatement(s) => s.compute_digest(),
             BodyItem::ExpressionStatement(es) => es.compute_digest(),
             BodyItem::VariableDeclaration(vs) => vs.compute_digest(),
             BodyItem::ReturnStatement(rs) => rs.compute_digest(),
+        });
+
+        for a in self.get_attrs_mut() {
+            hasher.update(a.compute_digest());
         }
+        hasher.finalize().into()
     }
 }
 

src/wasm-lib/kcl/src/parsing/ast/types/mod.rs

@@ -52,7 +52,7 @@ pub struct Node<T> {
     #[serde(default, skip_serializing_if = "ModuleId::is_top_level")]
     pub module_id: ModuleId,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub trivia: NodeList<NonCodeNode>,
+    pub outer_attrs: NodeList<Annotation>,
 }
 
 impl<T> Node<T> {
@@ -96,7 +96,7 @@ impl<T> Node<T> {
             start,
             end,
             module_id,
-            trivia: Vec::new(),
+            outer_attrs: Vec::new(),
         }
     }
 
@@ -106,7 +106,7 @@ impl<T> Node<T> {
             start: 0,
             end: 0,
             module_id: ModuleId::default(),
-            trivia: Vec::new(),
+            outer_attrs: Vec::new(),
         }
     }
 
@@ -116,7 +116,7 @@ impl<T> Node<T> {
             start,
             end,
             module_id,
-            trivia: Vec::new(),
+            outer_attrs: Vec::new(),
         })
     }
 
@@ -181,6 +181,8 @@ pub struct Program {
     pub non_code_meta: NonCodeMeta,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub shebang: Option<Node<Shebang>>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub inner_attrs: NodeList<Annotation>,
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
     #[ts(optional)]
@@ -261,28 +263,12 @@ impl Node<Program> {
         Ok(findings)
     }
 
-    pub fn annotations(&self) -> impl Iterator<Item = &Node<NonCodeNode>> {
-        self.non_code_meta
-            .start_nodes
-            .iter()
-            .filter(|n| n.value_is_annotation())
-    }
-
-    pub fn annotations_mut(&mut self) -> impl Iterator<Item = &mut Node<NonCodeNode>> {
-        self.non_code_meta
-            .start_nodes
-            .iter_mut()
-            .filter(|n| n.value_is_annotation())
-    }
-
     /// Get the annotations for the meta settings from the kcl file.
     pub fn meta_settings(&self) -> Result<Option<crate::execution::MetaSettings>, KclError> {
-        for annotation_node in self.annotations() {
+        for annotation in &self.inner_attrs {
-            let annotation = &annotation_node.value;
+            if annotation.name() == Some(annotations::SETTINGS) {
-            if annotation.annotation_name() == Some(annotations::SETTINGS) {
-                let source_range = annotation_node.as_source_range();
                 let mut meta_settings = crate::execution::MetaSettings::default();
-                meta_settings.update_from_annotation(annotation, source_range)?;
+                meta_settings.update_from_annotation(annotation)?;
                 return Ok(Some(meta_settings));
             }
         }
@@ -293,24 +279,18 @@ impl Node<Program> {
     pub fn change_meta_settings(&mut self, settings: crate::execution::MetaSettings) -> Result<Self, KclError> {
         let mut new_program = self.clone();
         let mut found = false;
-        for node in new_program.annotations_mut() {
+        for node in &mut new_program.inner_attrs {
-            if node.value.annotation_name() == Some(annotations::SETTINGS) {
+            if node.name() == Some(annotations::SETTINGS) {
-                let annotation = NonCodeValue::new_from_meta_settings(&settings);
+                *node = Node::no_src(Annotation::new_from_meta_settings(&settings));
-                *node = Node::no_src(NonCodeNode {
-                    value: annotation,
-                    digest: None,
-                });
                 found = true;
                 break;
             }
         }
 
         if !found {
-            let annotation = NonCodeValue::new_from_meta_settings(&settings);
+            new_program
-            new_program.non_code_meta.start_nodes.push(Node::no_src(NonCodeNode {
+                .inner_attrs
-                value: annotation,
+                .push(Node::no_src(Annotation::new_from_meta_settings(&settings)));
-                digest: None,
-            }));
         }
 
         Ok(new_program)
@@ -318,6 +298,10 @@ impl Node<Program> {
 }
 
 impl Program {
+    #[cfg(test)]
+    pub fn empty() -> Node<Self> {
+        Node::no_src(Program::default())
+    }
     /// Is the last body item an expression?
     pub fn ends_with_expr(&self) -> bool {
         let Some(ref last) = self.body.last() else {
@@ -629,6 +613,33 @@ impl BodyItem {
             BodyItem::ReturnStatement(return_statement) => return_statement.end,
         }
     }
+
+    pub(crate) fn set_attrs(&mut self, attr: NodeList<Annotation>) {
+        match self {
+            BodyItem::ImportStatement(node) => node.outer_attrs = attr,
+            BodyItem::ExpressionStatement(node) => node.outer_attrs = attr,
+            BodyItem::VariableDeclaration(node) => node.outer_attrs = attr,
+            BodyItem::ReturnStatement(node) => node.outer_attrs = attr,
+        }
+    }
+
+    pub(crate) fn get_attrs(&self) -> &[Node<Annotation>] {
+        match self {
+            BodyItem::ImportStatement(node) => &node.outer_attrs,
+            BodyItem::ExpressionStatement(node) => &node.outer_attrs,
+            BodyItem::VariableDeclaration(node) => &node.outer_attrs,
+            BodyItem::ReturnStatement(node) => &node.outer_attrs,
+        }
+    }
+
+    pub(crate) fn get_attrs_mut(&mut self) -> &mut [Node<Annotation>] {
+        match self {
+            BodyItem::ImportStatement(node) => &mut node.outer_attrs,
+            BodyItem::ExpressionStatement(node) => &mut node.outer_attrs,
+            BodyItem::VariableDeclaration(node) => &mut node.outer_attrs,
+            BodyItem::ReturnStatement(node) => &mut node.outer_attrs,
+        }
+    }
 }
 
 impl From<BodyItem> for SourceRange {
@@ -1134,24 +1145,6 @@ impl NonCodeNode {
             NonCodeValue::BlockComment { value, style: _ } => value.clone(),
             NonCodeValue::NewLineBlockComment { value, style: _ } => value.clone(),
             NonCodeValue::NewLine => "\n\n".to_string(),
-            n @ NonCodeValue::Annotation { .. } => n.annotation_name().unwrap_or("").to_owned(),
-        }
-    }
-
-    pub fn annotation(&self) -> Option<&NonCodeValue> {
-        match &self.value {
-            a @ NonCodeValue::Annotation { .. } => Some(a),
-            _ => None,
-        }
-    }
-
-    pub fn value_is_annotation(&self) -> bool {
-        match self.value {
-            NonCodeValue::InlineComment { .. }
-            | NonCodeValue::BlockComment { .. }
-            | NonCodeValue::NewLineBlockComment { .. }
-            | NonCodeValue::NewLine => false,
-            NonCodeValue::Annotation { .. } => true,
         }
     }
 }
@@ -1202,37 +1195,6 @@ pub enum NonCodeValue {
     // A new line like `\n\n` NOT a new line like `\n`.
     // This is also not a comment.
     NewLine,
-    Annotation {
-        name: Option<Node<Identifier>>,
-        properties: Option<Vec<Node<ObjectProperty>>>,
-    },
-}
-
-impl NonCodeValue {
-    pub fn annotation_name(&self) -> Option<&str> {
-        match self {
-            NonCodeValue::Annotation { name, .. } => name.as_ref().map(|i| &*i.name),
-            _ => None,
-        }
-    }
-
-    pub fn new_from_meta_settings(settings: &crate::execution::MetaSettings) -> NonCodeValue {
-        let mut properties: Vec<Node<ObjectProperty>> = vec![ObjectProperty::new(
-            Identifier::new(annotations::SETTINGS_UNIT_LENGTH),
-            Expr::Identifier(Box::new(Identifier::new(&settings.default_length_units.to_string()))),
-        )];
-
-        if settings.default_angle_units != Default::default() {
-            properties.push(ObjectProperty::new(
-                Identifier::new(annotations::SETTINGS_UNIT_ANGLE),
-                Expr::Identifier(Box::new(Identifier::new(&settings.default_angle_units.to_string()))),
-            ));
-        }
-        NonCodeValue::Annotation {
-            name: Some(Identifier::new(annotations::SETTINGS)),
-            properties: Some(properties),
-        }
-    }
 }
 
 #[derive(Debug, Default, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
@@ -1314,6 +1276,47 @@ impl<'de> Deserialize<'de> for NonCodeMeta {
     }
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[ts(export)]
+#[serde(tag = "type")]
+pub struct Annotation {
+    pub name: Option<Node<Identifier>>,
+    pub properties: Option<Vec<Node<ObjectProperty>>>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[ts(optional)]
+    pub digest: Option<Digest>,
+}
+
+impl Annotation {
+    pub fn is_inner(&self) -> bool {
+        self.name.is_some()
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(|n| &*n.name)
+    }
+
+    pub fn new_from_meta_settings(settings: &crate::execution::MetaSettings) -> Annotation {
+        let mut properties: Vec<Node<ObjectProperty>> = vec![ObjectProperty::new(
+            Identifier::new(annotations::SETTINGS_UNIT_LENGTH),
+            Expr::Identifier(Box::new(Identifier::new(&settings.default_length_units.to_string()))),
+        )];
+
+        if settings.default_angle_units != Default::default() {
+            properties.push(ObjectProperty::new(
+                Identifier::new(annotations::SETTINGS_UNIT_ANGLE),
+                Expr::Identifier(Box::new(Identifier::new(&settings.default_angle_units.to_string()))),
+            ));
+        }
+        Annotation {
+            name: Some(Identifier::new(annotations::SETTINGS)),
+            properties: Some(properties),
+            digest: None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
 #[serde(tag = "type")]
@@ -3823,12 +3826,7 @@ const cylinder = startSketchOn('-XZ')
                 (0..=0),
                 Node::no_src(FunctionExpression {
                     params: vec![],
-                    body: Node::no_src(Program {
+                    body: Program::empty(),
-                        body: Vec::new(),
-                        non_code_meta: Default::default(),
-                        shebang: None,
-                        digest: None,
-                    }),
                     return_type: None,
                     digest: None,
                 }),
@@ -3847,18 +3845,7 @@ const cylinder = startSketchOn('-XZ')
                         labeled: true,
                         digest: None,
                     }],
-                    body: Node {
+                    body: Program::empty(),
-                        inner: Program {
-                            body: Vec::new(),
-                            non_code_meta: Default::default(),
-                            shebang: None,
-                            digest: None,
-                        },
-                        start: 0,
-                        end: 0,
-                        module_id: ModuleId::default(),
-                        trivia: Vec::new(),
-                    },
                     return_type: None,
                     digest: None,
                 }),
@@ -3877,18 +3864,7 @@ const cylinder = startSketchOn('-XZ')
                         labeled: true,
                         digest: None,
                     }],
-                    body: Node {
+                    body: Program::empty(),
-                        inner: Program {
-                            body: Vec::new(),
-                            non_code_meta: Default::default(),
-                            shebang: None,
-                            digest: None,
-                        },
-                        start: 0,
-                        end: 0,
-                        module_id: ModuleId::default(),
-                        trivia: Vec::new(),
-                    },
                     return_type: None,
                     digest: None,
                 }),
@@ -3919,18 +3895,7 @@ const cylinder = startSketchOn('-XZ')
                             digest: None,
                         },
                     ],
-                    body: Node {
+                    body: Program::empty(),
-                        inner: Program {
-                            body: Vec::new(),
-                            non_code_meta: Default::default(),
-                            shebang: None,
-                            digest: None,
-                        },
-                        start: 0,
-                        end: 0,
-                        module_id: ModuleId::default(),
-                        trivia: Vec::new(),
-                    },
                     return_type: None,
                     digest: None,
                 }),

src/wasm-lib/kcl/src/parsing/parser.rs

@@ -21,13 +21,13 @@ use crate::{
     errors::{CompilationError, Severity, Tag},
     parsing::{
         ast::types::{
-            ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem, BoxNode,
+            Annotation, ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem,
-            CallExpression, CallExpressionKw, CommentStyle, DefaultParamVal, ElseIf, Expr, ExpressionStatement,
+            BoxNode, CallExpression, CallExpressionKw, CommentStyle, DefaultParamVal, ElseIf, Expr,
-            FnArgPrimitive, FnArgType, FunctionExpression, Identifier, IfExpression, ImportItem, ImportSelector,
+            ExpressionStatement, FnArgPrimitive, FnArgType, FunctionExpression, Identifier, IfExpression, ImportItem,
-            ImportStatement, ItemVisibility, LabeledArg, Literal, LiteralIdentifier, LiteralValue, MemberExpression,
+            ImportSelector, ImportStatement, ItemVisibility, LabeledArg, Literal, LiteralIdentifier, LiteralValue,
-            MemberObject, Node, NodeList, NonCodeMeta, NonCodeNode, NonCodeValue, ObjectExpression, ObjectProperty,
+            MemberExpression, MemberObject, Node, NodeList, NonCodeMeta, NonCodeNode, NonCodeValue, ObjectExpression,
-            Parameter, PipeExpression, PipeSubstitution, Program, ReturnStatement, Shebang, TagDeclarator,
+            ObjectProperty, Parameter, PipeExpression, PipeSubstitution, Program, ReturnStatement, Shebang,
-            UnaryExpression, UnaryOperator, VariableDeclaration, VariableDeclarator, VariableKind,
+            TagDeclarator, UnaryExpression, UnaryOperator, VariableDeclaration, VariableDeclarator, VariableKind,
         },
         math::BinaryExpressionToken,
         token::{Token, TokenSlice, TokenType},
@@ -284,7 +284,7 @@ fn non_code_node(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
     alt((non_code_node_leading_whitespace, non_code_node_no_leading_whitespace)).parse_next(i)
 }
 
-fn annotation(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
+fn annotation(i: &mut TokenSlice) -> PResult<Node<Annotation>> {
     let at = at_sign.parse_next(i)?;
     let name = opt(binding_name).parse_next(i)?;
     let mut end = name.as_ref().map(|n| n.end).unwrap_or(at.end);
@@ -308,7 +308,7 @@ fn annotation(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
                     value,
                     digest: None,
                 },
-                trivia: Vec::new(),
+                outer_attrs: Vec::new(),
             }),
             comma_sep,
         )
@@ -327,19 +327,16 @@ fn annotation(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
         ));
     }
 
-    let value = NonCodeValue::Annotation { name, properties };
+    let value = Annotation {
-    Ok(Node::new(
+        name,
-        NonCodeNode { value, digest: None },
+        properties,
-        at.start,
+        digest: None,
-        end,
+    };
-        at.module_id,
+    Ok(Node::new(value, at.start, end, at.module_id))
-    ))
 }
 
 // Matches remaining three cases of NonCodeValue
 fn non_code_node_no_leading_whitespace(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
-    alt((
-        annotation,
     any.verify_map(|token: Token| {
         if token.is_code_token() {
             None
@@ -369,8 +366,7 @@ fn non_code_node_no_leading_whitespace(i: &mut TokenSlice) -> PResult<Node<NonCo
             ))
         }
     })
-        .context(expected("Non-code token (comments or whitespace)")),
+    .context(expected("Non-code token (comments or whitespace)"))
-    ))
     .parse_next(i)
 }
 
@@ -427,7 +423,7 @@ fn pipe_expression(i: &mut TokenSlice) -> PResult<Node<PipeExpression>> {
             non_code_meta,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -830,7 +826,7 @@ fn object_property_same_key_and_val(i: &mut TokenSlice) -> PResult<Node<ObjectPr
             key,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -859,7 +855,7 @@ fn object_property(i: &mut TokenSlice) -> PResult<Node<ObjectProperty>> {
             value: expr,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     };
 
     if sep.token_type == TokenType::Colon {
@@ -1131,17 +1127,7 @@ fn function_decl(i: &mut TokenSlice) -> PResult<(Node<FunctionExpression>, bool)
     let close: Option<(Vec<Vec<Token>>, Token)> = opt((repeat(0.., whitespace), close_brace)).parse_next(i)?;
     let (body, end) = match close {
         Some((_, end)) => (
-            Node::new(
+            Node::new(Program::default(), brace.end, brace.end, brace.module_id),
-                Program {
-                    body: Vec::new(),
-                    non_code_meta: NonCodeMeta::default(),
-                    shebang: None,
-                    digest: None,
-                },
-                brace.end,
-                brace.end,
-                brace.module_id,
-            ),
             end.end,
         ),
         None => (function_body(i)?, close_brace(i)?.end),
@@ -1277,7 +1263,6 @@ fn noncode_just_after_code(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
                     x @ NonCodeValue::InlineComment { .. } => x,
                     x @ NonCodeValue::NewLineBlockComment { .. } => x,
                     x @ NonCodeValue::NewLine => x,
-                    x @ NonCodeValue::Annotation { .. } => x,
                 };
                 Node::new(
                     NonCodeNode { value, ..nc.inner },
@@ -1298,7 +1283,6 @@ fn noncode_just_after_code(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
                     x @ NonCodeValue::InlineComment { .. } => x,
                     x @ NonCodeValue::NewLineBlockComment { .. } => x,
                     x @ NonCodeValue::NewLine => x,
-                    x @ NonCodeValue::Annotation { .. } => x,
                 };
                 Node::new(NonCodeNode { value, ..nc.inner }, nc.start, nc.end, nc.module_id)
             }
@@ -1314,6 +1298,7 @@ fn noncode_just_after_code(i: &mut TokenSlice) -> PResult<Node<NonCodeNode>> {
 #[derive(Debug)]
 #[allow(clippy::large_enum_variant)]
 enum WithinFunction {
+    Annotation(Node<Annotation>),
     BodyItem((BodyItem, Option<Node<NonCodeNode>>)),
     NonCode(Node<NonCodeNode>),
 }
@@ -1338,9 +1323,12 @@ fn body_items_within_function(i: &mut TokenSlice) -> PResult<WithinFunction> {
             (import_stmt.map(BodyItem::ImportStatement), opt(noncode_just_after_code)).map(WithinFunction::BodyItem),
         Token { ref value, .. } if value == "return" =>
             (return_stmt.map(BodyItem::ReturnStatement), opt(noncode_just_after_code)).map(WithinFunction::BodyItem),
-        token if !token.is_code_token() || token.token_type == TokenType::At => {
+        token if !token.is_code_token() => {
             non_code_node.map(WithinFunction::NonCode)
         },
+        token if token.token_type == TokenType::At => {
+            annotation.map(WithinFunction::Annotation)
+        },
         _ =>
             alt((
                 (
@@ -1447,16 +1435,32 @@ fn function_body(i: &mut TokenSlice) -> PResult<Node<Program>> {
     }
 
     let mut body = Vec::new();
+    let mut inner_attrs = Vec::new();
+    let mut pending_attrs = Vec::new();
     let mut non_code_meta = NonCodeMeta::default();
     let mut end = 0;
     let mut start = leading_whitespace_start;
     for thing_in_body in things_within_body {
         match thing_in_body {
-            WithinFunction::BodyItem((b, maybe_noncode)) => {
+            WithinFunction::Annotation(attr) => {
+                if start.is_none() {
+                    start = Some((attr.start, attr.module_id))
+                }
+                if attr.is_inner() {
+                    inner_attrs.push(attr);
+                } else {
+                    pending_attrs.push(attr);
+                }
+            }
+            WithinFunction::BodyItem((mut b, maybe_noncode)) => {
                 if start.is_none() {
                     start = Some((b.start(), b.module_id()));
                 }
                 end = b.end();
+                if !pending_attrs.is_empty() {
+                    b.set_attrs(pending_attrs);
+                    pending_attrs = Vec::new();
+                }
                 body.push(b);
                 if let Some(nc) = maybe_noncode {
                     end = nc.end;
@@ -1476,9 +1480,26 @@ fn function_body(i: &mut TokenSlice) -> PResult<Node<Program>> {
             }
         }
     }
+
     let start = start.expect(
         "the `things_within_body` vec should have looped at least once, and each loop overwrites `start` if it is None",
     );
+
+    if !pending_attrs.is_empty() {
+        for a in pending_attrs {
+            ParseContext::err(CompilationError::err(
+                a.as_source_range(),
+                "Attribute is not attached to any item",
+            ));
+        }
+        return Err(ErrMode::Cut(
+            CompilationError::fatal(
+                SourceRange::new(start.0, end, start.1),
+                "Block contains un-attached attributes",
+            )
+            .into(),
+        ));
+    }
     // Safe to unwrap `body.first()` because `body` is `separated1` therefore guaranteed
     // to have len >= 1.
     let end_ws = opt(whitespace)
@@ -1492,6 +1513,7 @@ fn function_body(i: &mut TokenSlice) -> PResult<Node<Program>> {
         Program {
             body,
             non_code_meta,
+            inner_attrs,
             shebang: None,
             digest: None,
         },
@@ -1790,7 +1812,7 @@ fn return_stmt(i: &mut TokenSlice) -> PResult<Node<ReturnStatement>> {
         end: argument.end(),
         module_id: ret.module_id,
         inner: ReturnStatement { argument, digest: None },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -2017,13 +2039,13 @@ fn declaration(i: &mut TokenSlice) -> PResult<BoxNode<VariableDeclaration>> {
                     init: val,
                     digest: None,
                 },
-                trivia: Vec::new(),
+                outer_attrs: Vec::new(),
             },
             visibility,
             kind,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     }))
 }
 
@@ -2229,7 +2251,7 @@ fn unary_expression(i: &mut TokenSlice) -> PResult<Node<UnaryExpression>> {
             argument,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -2310,7 +2332,7 @@ fn expression_stmt(i: &mut TokenSlice) -> PResult<Node<ExpressionStatement>> {
             expression: val,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -2750,7 +2772,7 @@ fn fn_call(i: &mut TokenSlice) -> PResult<Node<CallExpression>> {
             arguments: args,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -2780,7 +2802,7 @@ fn fn_call_kw(i: &mut TokenSlice) -> PResult<Node<CallExpressionKw>> {
             arguments: args,
             digest: None,
         },
-        trivia: Vec::new(),
+        outer_attrs: Vec::new(),
     })
 }
 
@@ -3023,6 +3045,7 @@ mySk1 = startSketchAt([0, 0])"#;
                                 )],
                                 digest: None,
                             },
+                            inner_attrs: Vec::new(),
                             shebang: None,
                             digest: None,
                         },
@@ -3700,6 +3723,7 @@ mySk1 = startSketchAt([0, 0])"#;
                 ))],
                 shebang: None,
                 non_code_meta: NonCodeMeta::default(),
+                inner_attrs: Vec::new(),
                 digest: None,
             },
             0,

src/wasm-lib/kcl/src/unparser.rs

@@ -2,11 +2,12 @@ use std::fmt::Write;
 
 use crate::parsing::{
     ast::types::{
-        ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem, CallExpression,
+        Annotation, ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem,
-        CallExpressionKw, CommentStyle, DefaultParamVal, Expr, FnArgType, FormatOptions, FunctionExpression,
+        CallExpression, CallExpressionKw, CommentStyle, DefaultParamVal, Expr, FnArgType, FormatOptions,
-        IfExpression, ImportSelector, ImportStatement, ItemVisibility, LabeledArg, Literal, LiteralIdentifier,
+        FunctionExpression, IfExpression, ImportSelector, ImportStatement, ItemVisibility, LabeledArg, Literal,
-        LiteralValue, MemberExpression, MemberObject, Node, NonCodeNode, NonCodeValue, ObjectExpression, Parameter,
+        LiteralIdentifier, LiteralValue, MemberExpression, MemberObject, Node, NonCodeNode, NonCodeValue,
-        PipeExpression, Program, TagDeclarator, UnaryExpression, VariableDeclaration, VariableKind,
+        ObjectExpression, Parameter, PipeExpression, Program, TagDeclarator, UnaryExpression, VariableDeclaration,
+        VariableKind,
     },
     token::NumericSuffix,
     PIPE_OPERATOR,
@@ -22,6 +23,9 @@ impl Program {
             .map(|sh| format!("{}\n\n", sh.inner.content))
             .unwrap_or_default();
 
+        for attr in &self.inner_attrs {
+            result.push_str(&attr.recast(options, indentation_level));
+        }
         for start in &self.non_code_meta.start_nodes {
             result.push_str(&start.recast(options, indentation_level));
         }
@@ -30,7 +34,12 @@ impl Program {
         let result = self
             .body
             .iter()
-            .map(|body_item| match body_item.clone() {
+            .map(|body_item| {
+                let mut result = String::new();
+                for attr in body_item.get_attrs() {
+                    result.push_str(&attr.recast(options, indentation_level));
+                }
+                result.push_str(&match body_item.clone() {
                     BodyItem::ImportStatement(stmt) => stmt.recast(options, indentation_level),
                     BodyItem::ExpressionStatement(expression_statement) => {
                         expression_statement
@@ -50,10 +59,13 @@ impl Program {
                                 .trim_start()
                         )
                     }
+                });
+                result
             })
             .enumerate()
             .fold(result, |mut output, (index, recast_str)| {
-                let start_string = if index == 0 && self.non_code_meta.start_nodes.is_empty() {
+                let start_string =
+                    if index == 0 && self.non_code_meta.start_nodes.is_empty() && self.inner_attrs.is_empty() {
                         // We need to indent.
                         indentation.to_string()
                     } else {
@@ -113,9 +125,7 @@ impl NonCodeValue {
     fn should_cause_array_newline(&self) -> bool {
         match self {
             Self::InlineComment { .. } => false,
-            Self::BlockComment { .. } | Self::NewLineBlockComment { .. } | Self::NewLine | Self::Annotation { .. } => {
+            Self::BlockComment { .. } | Self::NewLineBlockComment { .. } | Self::NewLine => true,
-                true
-            }
         }
     }
 }
@@ -156,12 +166,17 @@ impl Node<NonCodeNode> {
                 }
             }
             NonCodeValue::NewLine => "\n\n".to_string(),
-            NonCodeValue::Annotation { name, properties } => {
+        }
+    }
+}
+
+impl Node<Annotation> {
+    fn recast(&self, options: &FormatOptions, indentation_level: usize) -> String {
         let mut result = "@".to_owned();
-                if let Some(name) = name {
+        if let Some(name) = &self.name {
             result.push_str(&name.name);
         }
-                if let Some(properties) = properties {
+        if let Some(properties) = &self.properties {
             result.push('(');
             result.push_str(
                 &properties
@@ -184,8 +199,6 @@ impl Node<NonCodeNode> {
 
         result
     }
-        }
-    }
 }
 
 impl ImportStatement {

src/wasm-lib/kcl/tests/import_cycle1/ast.snap

@@ -103,26 +103,9 @@ description: Result of parsing import_cycle1.kcl
       }
     ],
     "end": 110,
-    "nonCodeMeta": {
+    "innerAttrs": [
-      "nonCodeNodes": {
-        "0": [
-          {
-            "end": 71,
-            "start": 69,
-            "type": "NonCodeNode",
-            "value": {
-              "type": "newLine"
-            }
-          }
-        ]
-      },
-      "startNodes": [
       {
         "end": 33,
-          "start": 0,
-          "type": "NonCodeNode",
-          "value": {
-            "type": "annotation",
         "name": {
           "end": 9,
           "name": "settings",
@@ -148,11 +131,26 @@ description: Result of parsing import_cycle1.kcl
               "type": "Identifier"
             }
           }
-            ]
+        ],
+        "start": 0,
+        "type": "Annotation"
+      }
+    ],
+    "nonCodeMeta": {
+      "nonCodeNodes": {
+        "0": [
+          {
+            "end": 71,
+            "start": 69,
+            "type": "NonCodeNode",
+            "value": {
+              "type": "newLine"
             }
           }
         ]
       },
+      "startNodes": []
+    },
     "start": 0
   }
 }

src/wasm-lib/kcl/tests/import_function_not_sketch/ast.snap

@@ -103,26 +103,9 @@ description: Result of parsing import_function_not_sketch.kcl
       }
     ],
     "end": 109,
-    "nonCodeMeta": {
+    "innerAttrs": [
-      "nonCodeNodes": {
-        "0": [
-          {
-            "end": 70,
-            "start": 68,
-            "type": "NonCodeNode",
-            "value": {
-              "type": "newLine"
-            }
-          }
-        ]
-      },
-      "startNodes": [
       {
         "end": 33,
-          "start": 0,
-          "type": "NonCodeNode",
-          "value": {
-            "type": "annotation",
         "name": {
           "end": 9,
           "name": "settings",
@@ -148,11 +131,26 @@ description: Result of parsing import_function_not_sketch.kcl
               "type": "Identifier"
             }
           }
-            ]
+        ],
+        "start": 0,
+        "type": "Annotation"
+      }
+    ],
+    "nonCodeMeta": {
+      "nonCodeNodes": {
+        "0": [
+          {
+            "end": 70,
+            "start": 68,
+            "type": "NonCodeNode",
+            "value": {
+              "type": "newLine"
             }
           }
         ]
       },
+      "startNodes": []
+    },
     "start": 0
   }
 }

src/wasm-lib/kcl/tests/import_whole/ast.snap

@@ -115,26 +115,9 @@ description: Result of parsing import_whole.kcl
       }
     ],
     "end": 124,
-    "nonCodeMeta": {
+    "innerAttrs": [
-      "nonCodeNodes": {
-        "0": [
-          {
-            "end": 68,
-            "start": 66,
-            "type": "NonCodeNode",
-            "value": {
-              "type": "newLine"
-            }
-          }
-        ]
-      },
-      "startNodes": [
       {
         "end": 33,
-          "start": 0,
-          "type": "NonCodeNode",
-          "value": {
-            "type": "annotation",
         "name": {
           "end": 9,
           "name": "settings",
@@ -160,11 +143,26 @@ description: Result of parsing import_whole.kcl
               "type": "Identifier"
             }
           }
-            ]
+        ],
+        "start": 0,
+        "type": "Annotation"
+      }
+    ],
+    "nonCodeMeta": {
+      "nonCodeNodes": {
+        "0": [
+          {
+            "end": 68,
+            "start": 66,
+            "type": "NonCodeNode",
+            "value": {
+              "type": "newLine"
             }
           }
         ]
       },
+      "startNodes": []
+    },
     "start": 0
   }
 }