Add bodyType to Revolve P&C

src/lang/modifyAst/sweeps.spec.ts

@@ -27,6 +27,7 @@ import {
   addSweep,
   getAxisExpressionAndIndex,
   retrieveAxisOrEdgeSelectionsFromOpArg,
+  retrieveBodyTypeFromOpArg,
 } from '@src/lang/modifyAst/sweeps'
 import type { Node } from '@rust/kcl-lib/bindings/Node'
 import type { ConnectionManager } from '@src/network/connectionManager'
@@ -832,6 +833,41 @@ profile001 = circle(sketch001, center = [3, 0], radius = 1)`
       )
     })
 
+    it('should add basic revolve call with surface bodyType', async () => {
+      const { ast, sketches } = await getAstAndSketchSelections(
+        circleCode,
+        instanceInThisFile,
+        kclManagerInThisFile
+      )
+      expect(sketches.graphSelections).toHaveLength(1)
+      const angle = await getKclCommandValue(
+        '10',
+        instanceInThisFile,
+        rustContextInThisFile
+      )
+      const axis = 'X'
+      const result = addRevolve({
+        ast,
+        sketches,
+        angle,
+        axis,
+        bodyType: 'SURFACE',
+        wasmInstance: instanceInThisFile,
+      })
+      if (err(result)) throw result
+      await runNewAstAndCheckForSweep(result.modifiedAst, rustContextInThisFile)
+      const newCode = recast(result.modifiedAst, instanceInThisFile)
+      expect(newCode).toContain(circleCode)
+      expect(newCode).toContain(
+        `revolve001 = revolve(
+  profile001,
+  angle = 10,
+  axis = X,
+  bodyType = SURFACE,
+)`
+      )
+    })
+
     it('should add basic revolve call with symmetric true', async () => {
       const { ast, sketches } = await getAstAndSketchSelections(
         circleCode,
@@ -1157,4 +1193,40 @@ helix001 = helix(
       expect(result.axis).toBeUndefined()
     })
   })
+
+  describe('Testing retrieveBodyTypeFromOpArg', () => {
+    async function findBodyTypeArg(code: string) {
+      const ast = assertParse(code, instanceInThisFile)
+      const { operations } = await enginelessExecutor(
+        ast,
+        rustContextInThisFile
+      )
+      const op = operations.find(
+        (o) => o.type === 'StdLibCall' && o.name === 'extrude'
+      )
+      if (!op || op.type !== 'StdLibCall' || !op.labeledArgs.bodyType) {
+        throw new Error('Extrude operation not found')
+      }
+
+      return op.labeledArgs.bodyType
+    }
+
+    it('should return SOLID bodyType from op argument', async () => {
+      const code = `${circleProfileCode}
+extrude001 = extrude(profile001, length = 1, bodyType = SOLID)`
+      const opArg = await findBodyTypeArg(code)
+      const result = retrieveBodyTypeFromOpArg(opArg, code)
+      if (err(result)) throw result
+      expect(result).toEqual('SOLID')
+    })
+
+    it('should return SURFACE bodyType from op argument', async () => {
+      const code = `${circleProfileCode}
+extrude001 = extrude(profile001, length = 1, bodyType = SURFACE)`
+      const opArg = await findBodyTypeArg(code)
+      const result = retrieveBodyTypeFromOpArg(opArg, code)
+      if (err(result)) throw result
+      expect(result).toEqual('SURFACE')
+    })
+  })
 })

src/lang/modifyAst/sweeps.ts

@@ -41,6 +41,8 @@ import {
   KCL_DEFAULT_CONSTANT_PREFIXES,
   type KclPreludeExtrudeMethod,
   type KclPreludeBodyType,
+  KCL_PRELUDE_BODY_TYPE_SOLID,
+  KCL_PRELUDE_BODY_TYPE_SURFACE,
 } from '@src/lib/constants'
 import { err } from '@src/lib/trap'
 import type { Selections } from '@src/machines/modelingSharedTypes'
@@ -453,6 +455,7 @@ export function addRevolve({
   bidirectionalAngle,
   tagStart,
   tagEnd,
+  bodyType,
   nodeToEdit,
 }: {
   ast: Node<Program>
@@ -465,6 +468,7 @@ export function addRevolve({
   bidirectionalAngle?: KclCommandValue
   tagStart?: string
   tagEnd?: string
+  bodyType?: KclPreludeBodyType
   nodeToEdit?: PathToNode
 }):
   | {
@@ -517,6 +521,9 @@ export function addRevolve({
   const tagEndExpr = tagEnd
     ? [createLabeledArg('tagEnd', createTagDeclarator(tagEnd))]
     : []
+  const bodyTypeExpr = bodyType
+    ? [createLabeledArg('bodyType', createLocalName(bodyType))]
+    : []
 
   const sketchesExpr = createVariableExpressionsArray(vars.exprs)
   const call = createCallExpressionStdLibKw('revolve', sketchesExpr, [
@@ -526,6 +533,7 @@ export function addRevolve({
     ...bidirectionalAngleExpr,
     ...tagStartExpr,
     ...tagEndExpr,
+    ...bodyTypeExpr,
   ])
 
   // Insert variables for labeled arguments if provided
@@ -732,3 +740,21 @@ export function retrieveTagDeclaratorFromOpArg(
     toUtf16(opArg.sourceRange[1], code)
   )
 }
+
+export function retrieveBodyTypeFromOpArg(
+  opArg: OpArg,
+  code: string
+): KclPreludeBodyType | Error {
+  /** Version of `toUtf16` bound to our code, for mapping source range values. */
+  const boundToUtf16 = (n: number) => toUtf16(n, code)
+  const result = code.slice(...opArg.sourceRange.map(boundToUtf16))
+  if (result === KCL_PRELUDE_BODY_TYPE_SOLID) {
+    return KCL_PRELUDE_BODY_TYPE_SOLID
+  }
+
+  if (result === KCL_PRELUDE_BODY_TYPE_SURFACE) {
+    return KCL_PRELUDE_BODY_TYPE_SURFACE
+  }
+
+  return new Error("Couldn't retrieve bodyType argument")
+}

src/lib/commandBarConfigs/modelingCommandConfig.ts

@@ -112,6 +112,12 @@ const objectsTypesAndFilters: {
   selectionFilter: ['object'],
 }
 
+// For all surface modeling commands
+const kclBodyTypeOptions = KCL_PRELUDE_BODY_TYPE_VALUES.map((value) => ({
+  name: capitaliseFC(value.toLowerCase()),
+  value,
+}))
+
 const hasEngineConnection = (
   engineCommandManager: ConnectionManager
 ): true | Error => {
@@ -188,6 +194,7 @@ export type ModelingCommandSchema = {
     tagEnd?: string
     symmetric?: boolean
     bidirectionalAngle?: KclCommandValue
+    bodyType?: KclPreludeBodyType
   }
   Shell: {
     // Enables editing workflow
@@ -637,10 +644,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
       bodyType: {
         inputType: 'options',
         required: false,
-        options: KCL_PRELUDE_BODY_TYPE_VALUES.map((value) => ({
-          name: capitaliseFC(value.toLowerCase()),
-          value,
-        })),
+        options: kclBodyTypeOptions,
       },
     },
   },
@@ -865,6 +869,11 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
         inputType: 'tagDeclarator',
         required: false,
       },
+      bodyType: {
+        inputType: 'options',
+        required: false,
+        options: kclBodyTypeOptions,
+      },
     },
   },
   Shell: {

src/lib/operations.ts

@@ -11,6 +11,7 @@ import {
 } from '@src/lang/modifyAst/faces'
 import {
   retrieveAxisOrEdgeSelectionsFromOpArg,
+  retrieveBodyTypeFromOpArg,
   retrieveTagDeclaratorFromOpArg,
   SWEEP_CONSTANTS,
   SWEEP_MODULE,
@@ -48,8 +49,6 @@ import { err } from '@src/lib/trap'
 import type { CommandBarMachineEvent } from '@src/machines/commandBarMachine'
 import { retrieveEdgeSelectionsFromOpArgs } from '@src/lang/modifyAst/edges'
 import {
-  KCL_PRELUDE_BODY_TYPE_SOLID,
-  KCL_PRELUDE_BODY_TYPE_SURFACE,
   type KclPreludeBodyType,
   KCL_PRELUDE_EXTRUDE_METHOD_MERGE,
   KCL_PRELUDE_EXTRUDE_METHOD_NEW,
@@ -407,16 +406,9 @@ const prepareToEditExtrude: PrepareToEditCallback = async ({
   // bodyType argument from a string
   let bodyType: KclPreludeBodyType | undefined
   if ('bodyType' in operation.labeledArgs && operation.labeledArgs.bodyType) {
-    const result = code.slice(
-      ...operation.labeledArgs.bodyType.sourceRange.map(boundToUtf16)
-    )
-    if (result === KCL_PRELUDE_BODY_TYPE_SOLID) {
-      bodyType = KCL_PRELUDE_BODY_TYPE_SOLID
-    } else if (result === KCL_PRELUDE_BODY_TYPE_SURFACE) {
-      bodyType = KCL_PRELUDE_BODY_TYPE_SURFACE
-    } else {
-      return { reason: "Couldn't retrieve bodyType argument" }
-    }
+    const res = retrieveBodyTypeFromOpArg(operation.labeledArgs.bodyType, code)
+    if (err(res)) return { reason: res.message }
+    bodyType = res
   }
 
   // 3. Assemble the default argument values for the command,
@@ -1349,6 +1341,14 @@ const prepareToEditRevolve: PrepareToEditCallback = async ({
     tagEnd = retrieveTagDeclaratorFromOpArg(operation.labeledArgs.tagEnd, code)
   }
 
+  // bodyType argument from a string
+  let bodyType: KclPreludeBodyType | undefined
+  if ('bodyType' in operation.labeledArgs && operation.labeledArgs.bodyType) {
+    const res = retrieveBodyTypeFromOpArg(operation.labeledArgs.bodyType, code)
+    if (err(res)) return { reason: res.message }
+    bodyType = res
+  }
+
   // 3. Assemble the default argument values for the command,
   // with `nodeToEdit` set, which will let the actor know
   // to edit the node that corresponds to the StdLibCall.
@@ -1362,6 +1362,7 @@ const prepareToEditRevolve: PrepareToEditCallback = async ({
     bidirectionalAngle,
     tagStart,
     tagEnd,
+    bodyType,
     nodeToEdit: pathToNodeFromRustNodePath(operation.nodePath),
   }
   return {