Fix to not have unneeded console errors (#4482)

* Fix to not have unneeded console errors

* Change to use a type that isn't string

src/clientSideScene/sceneEntities.ts

@@ -47,6 +47,7 @@ import {
   VariableDeclaration,
   VariableDeclarator,
   sketchFromKclValue,
+  sketchFromKclValueOptional,
 } from 'lang/wasm'
 import {
   engineCommandManager,
@@ -92,7 +93,7 @@ import {
   updateCenterRectangleSketch,
 } from 'lib/rectangleTool'
 import { getThemeColorForThreeJs, Themes } from 'lib/theme'
-import { err, reportRejection, trap } from 'lib/trap'
+import { err, Reason, reportRejection, trap } from 'lib/trap'
 import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer'
 import { Point3d } from 'wasm-lib/kcl/bindings/Point3d'
 import { SegmentInputs } from 'lang/std/stdTypes'
@@ -1697,10 +1698,13 @@ export class SceneEntities {
       this.sceneProgramMemory = programMemory
 
       const maybeSketch = programMemory.get(variableDeclarationName)
-      let sketch = undefined
-      const sg = sketchFromKclValue(maybeSketch, variableDeclarationName)
-      if (!err(sg)) {
-        sketch = sg
+      let sketch: Sketch | undefined
+      const sk = sketchFromKclValueOptional(
+        maybeSketch,
+        variableDeclarationName
+      )
+      if (!(sk instanceof Reason)) {
+        sketch = sk
       } else if ((maybeSketch as Solid).sketch) {
         sketch = (maybeSketch as Solid).sketch
       }

src/components/ModelingSidebar/ModelingPanes/MemoryPane.tsx

@@ -5,12 +5,12 @@ import {
   ProgramMemory,
   Path,
   ExtrudeSurface,
-  sketchFromKclValue,
+  sketchFromKclValueOptional,
 } from 'lang/wasm'
 import { useKclContext } from 'lang/KclProvider'
 import { useResolvedTheme } from 'hooks/useResolvedTheme'
 import { ActionButton } from 'components/ActionButton'
-import { err, trap } from 'lib/trap'
+import { Reason, trap } from 'lib/trap'
 import Tooltip from 'components/Tooltip'
 import { useModelingContext } from 'hooks/useModelingContext'
 
@@ -93,13 +93,13 @@ export const processMemory = (programMemory: ProgramMemory) => {
       // @ts-ignore
       val.type !== 'Function'
     ) {
-      const sg = sketchFromKclValue(val, key)
+      const sk = sketchFromKclValueOptional(val, key)
       if (val.type === 'Solid') {
         processedMemory[key] = val.value.map(({ ...rest }: ExtrudeSurface) => {
           return rest
         })
-      } else if (!err(sg)) {
-        processedMemory[key] = sg.paths.map(({ __geoMeta, ...rest }: Path) => {
+      } else if (!(sk instanceof Reason)) {
+        processedMemory[key] = sk.paths.map(({ __geoMeta, ...rest }: Path) => {
           return rest
         })
       } else {

src/lang/queryAst.ts

@@ -14,6 +14,7 @@ import {
   ProgramMemory,
   ReturnStatement,
   sketchFromKclValue,
+  sketchFromKclValueOptional,
   SourceRange,
   SyntaxType,
   VariableDeclaration,
@@ -27,7 +28,7 @@ import {
   getConstraintLevelFromSourceRange,
   getConstraintType,
 } from './std/sketchcombos'
-import { err } from 'lib/trap'
+import { err, Reason } from 'lib/trap'
 import { ImportStatement } from 'wasm-lib/kcl/bindings/ImportStatement'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
 
@@ -846,7 +847,8 @@ export function hasExtrudeSketch({
   const varName = varDec.declarations[0].id.name
   const varValue = programMemory?.get(varName)
   return (
-    varValue?.type === 'Solid' || !err(sketchFromKclValue(varValue, varName))
+    varValue?.type === 'Solid' ||
+    !(sketchFromKclValueOptional(varValue, varName) instanceof Reason)
   )
 }
 

src/lang/wasm.ts

@@ -32,7 +32,7 @@ import { CoreDumpManager } from 'lib/coredump'
 import openWindow from 'lib/openWindow'
 import { DefaultPlanes } from 'wasm-lib/kcl/bindings/DefaultPlanes'
 import { TEST } from 'env'
-import { err } from 'lib/trap'
+import { err, Reason } from 'lib/trap'
 import { Configuration } from 'wasm-lib/kcl/bindings/Configuration'
 import { DeepPartial } from 'lib/types'
 import { ProjectConfiguration } from 'wasm-lib/kcl/bindings/ProjectConfiguration'
@@ -365,10 +365,10 @@ export class ProgramMemory {
 }
 
 // TODO: In the future, make the parameter be a KclValue.
-export function sketchFromKclValue(
+export function sketchFromKclValueOptional(
   obj: any,
   varName: string | null
-): Sketch | Error {
+): Sketch | Reason {
   if (obj?.value?.type === 'Sketch') return obj.value
   if (obj?.value?.type === 'Solid') return obj.value.sketch
   if (obj?.type === 'Solid') return obj.sketch
@@ -377,15 +377,26 @@ export function sketchFromKclValue(
   }
   const actualType = obj?.value?.type ?? obj?.type
   if (actualType) {
-    console.log(obj)
-    return new Error(
+    return new Reason(
       `Expected ${varName} to be a sketch or solid, but it was ${actualType} instead.`
     )
   } else {
-    return new Error(`Expected ${varName} to be a sketch, but it wasn't.`)
+    return new Reason(`Expected ${varName} to be a sketch, but it wasn't.`)
   }
 }
 
+// TODO: In the future, make the parameter be a KclValue.
+export function sketchFromKclValue(
+  obj: any,
+  varName: string | null
+): Sketch | Error {
+  const result = sketchFromKclValueOptional(obj, varName)
+  if (result instanceof Reason) {
+    return result.toError()
+  }
+  return result
+}
+
 export const executor = async (
   node: Node<Program>,
   programMemory: ProgramMemory | Error = ProgramMemory.empty(),

src/lib/trap.ts

@@ -2,6 +2,23 @@ import toast from 'react-hot-toast'
 
 type ExcludeErr<T> = Exclude<T, Error>
 
+/**
+ * Similar to Error, but more lightweight, without the stack trace.  It can also
+ * be used to represent a reason for not being able to provide an alternative,
+ * which isn't necessarily an error.
+ */
+export class Reason {
+  message: string
+
+  constructor(message: string) {
+    this.message = message
+  }
+
+  toError() {
+    return new Error(this.message)
+  }
+}
+
 /**
  * This is intentionally *not* exported due to misuse.  We'd like to add a lint.
  */