More places need to know how to tell if a call is absolute, and map i…

…t to a tooltip if so

src/lang/std/sketch.ts

@@ -2369,30 +2369,47 @@ export function getConstraintInfo(
   )
 }
 
+/* Keyword functions like 'line' could be absolute or relative, depending on their parameters.
+But tooltips like 'line' or 'lineTo' are either relative or absolute. Not both.
+So, map (line, absolute) to lineTo, and (line, relative) to line. Etc.
+*/
+export function sketchFnNameToTooltip(
+  fnName: string,
+  isAbsolute: boolean
+): ToolTip | undefined {
+  switch (fnName) {
+    case 'line':
+      return isAbsolute ? 'lineTo' : fnName
+    case 'xLine':
+      return isAbsolute ? 'xLineTo' : fnName
+    case 'yLine':
+      return isAbsolute ? 'yLineTo' : fnName
+  }
+}
+
+export function sketchFnIsAbsolute(
+  callExpression: Node<CallExpressionKw>
+): boolean {
+  const fnName = callExpression.callee.name
+  return (
+    fnName === 'circleThreePoint' ||
+    findKwArg('endAbsolute', callExpression) !== undefined
+  )
+}
+
 export function getConstraintInfoKw(
   callExpression: Node<CallExpressionKw>,
   code: string,
   pathToNode: PathToNode,
   filterValue?: string
 ): ConstrainInfo[] {
   const fnName = callExpression?.callee?.name || ''
-  const isAbsolute =
-    fnName === 'circleThreePoint' ||
-    findKwArg('endAbsolute', callExpression) !== undefined
-  if (!(fnName in sketchLineHelperMapKw)) return []
-  const correctFnName = (() => {
-    switch (fnName) {
-      case 'line':
-        return isAbsolute ? 'lineTo' : fnName
-      case 'xLine':
-        return isAbsolute ? 'xLineTo' : fnName
-      case 'yLine':
-        return isAbsolute ? 'yLineTo' : fnName
-    }
-  })()
+  const isAbsolute = sketchFnIsAbsolute(callExpression)
+  const correctFnName = sketchFnNameToTooltip(fnName, isAbsolute)
   if (correctFnName === undefined) {
     return []
   }
+  if (!(correctFnName in sketchLineHelperMapKw)) return []
   return sketchLineHelperMapKw[correctFnName].getConstraintInfo(
     callExpression,
     code,

src/lang/std/sketchcombos.test.ts

@@ -21,7 +21,12 @@ import { err } from 'lib/trap'
 import { enginelessExecutor } from '../../lib/testHelpers'
 import { codeRefFromRange } from './artifactGraph'
 import { findKwArg } from 'lang/util'
-import { ARG_END, ARG_END_ABSOLUTE } from './sketch'
+import {
+  ARG_END,
+  ARG_END_ABSOLUTE,
+  sketchFnIsAbsolute,
+  sketchFnNameToTooltip,
+} from './sketch'
 
 beforeAll(async () => {
   await initPromise
@@ -124,9 +129,14 @@ function getConstraintTypeFromSourceHelper2(
 ): ReturnType<typeof getConstraintType> | Error {
   const ast = assertParse(code)
 
-  const arg = (ast.body[0] as any).expression.arguments[0] as Expr
-  const fnName = (ast.body[0] as any).expression.callee.name as ToolTip
-  return getConstraintType(arg, fnName, false)
+  const call = (ast.body[0] as any).expression
+  const arg = call.arguments[0] as Expr
+  const fnName = call.callee.name as ToolTip
+  const correctFnName = sketchFnNameToTooltip(fnName, sketchFnIsAbsolute(call))
+  if (correctFnName === undefined) {
+    return new Error(`could not map this ${fnName} call to a tooltip`)
+  }
+  return getConstraintType(arg, correctFnName, false)
 }
 
 function makeSelections(

src/lang/std/sketchcombos.ts

@@ -1755,17 +1755,16 @@ export function getConstraintType(
   fnName: ToolTip,
   isAbsolute: boolean
 ): LineInputsType | null {
+  if (fnName === 'xLine') return 'yRelative'
+  if (fnName === 'yLine') return 'xRelative'
+  if (fnName === 'xLineTo') return 'yAbsolute'
+  if (fnName === 'yLineTo') return 'xAbsolute'
   // this function assumes that for two val sketch functions that one arg is locked down not both
   // and for one val sketch functions that the arg is NOT locked down
   // these conditions should have been checked previously.
   // completely locked down or not locked down at all does not depend on the fnName so we can check that first
   const isArr = isArray(val)
-  if (!isArr) {
-    if (fnName === 'xLine') return 'yRelative'
-    if (fnName === 'yLine') return 'xRelative'
-    if (fnName === 'xLineTo') return 'yAbsolute'
-    if (fnName === 'yLineTo') return 'xAbsolute'
-  } else {
+  if (isArr) {
     const isFirstArgLockedDown = isNotLiteralArrayOrStatic(val[0])
     if (fnName === 'line' && !isAbsolute)
       return isFirstArgLockedDown ? 'xRelative' : 'yRelative'