Merge pull request #147 from Siubaak/claude/fix-issue-143-Z4efM

Author: Siubaak

src/evaluate/expression.ts

@@ -323,6 +323,32 @@ export function* ConditionalExpression(node: acorn.ConditionalExpression, scope:
     : (yield* evaluate(node.alternate, scope))
 }
 
+function getCalleeDesc(node: acorn.Expression | acorn.Super): string {
+  if (node.type === 'Identifier') {
+    return (node as acorn.Identifier).name
+  } else if (node.type === 'MemberExpression') {
+    const memberNode = node as acorn.MemberExpression
+    const objDesc = getCalleeDesc(memberNode.object)
+    if (!memberNode.computed) {
+      if (memberNode.property.type === 'PrivateIdentifier') {
+        return `${objDesc}.#${(memberNode.property as acorn.PrivateIdentifier).name}`
+      }
+      return `${objDesc}.${(memberNode.property as acorn.Identifier).name}`
+    }
+    const prop = memberNode.property as acorn.Expression
+    if (prop.type === 'Literal') {
+      return `${objDesc}[${(prop as acorn.Literal).raw}]`
+    }
+    if (prop.type === 'Identifier') {
+      return `${objDesc}[${(prop as acorn.Identifier).name}]`
+    }
+    return objDesc
+  } else if (node.type === 'Super') {
+    return 'super'
+  }
+  return '(intermediate value)'
+}
+
 export function* CallExpression(node: acorn.CallExpression, scope: Scope) {
   let func: any
   let object: any
@@ -371,9 +397,11 @@ export function* CallExpression(node: acorn.CallExpression, scope: Scope) {
     }
 
     if (typeof func !== 'function') {
-      throw new TypeError(`${key} is not a function`)
+      const calleeDesc = getCalleeDesc(node.callee as acorn.MemberExpression)
+      throw new TypeError(`${calleeDesc} is not a function`)
     } else if (CLSCTOR in func) {
-      throw new TypeError(`Class constructor ${key} cannot be invoked without 'new'`)
+      const calleeDesc = getCalleeDesc(node.callee as acorn.MemberExpression)
+      throw new TypeError(`Class constructor ${calleeDesc} cannot be invoked without 'new'`)
     }
   } else {
     func = yield* evaluate(node.callee, scope)

src/index.ts

@@ -18,6 +18,33 @@ export interface SvalOptions {
 
 const latestVer = 15
 
+function improveSyntaxError(err: SyntaxError & { pos?: number }, code: string): SyntaxError {
+  if (typeof err.pos !== 'number' || !err.message.startsWith('Unexpected token')) return err
+  const pos = err.pos
+  const ch = pos < code.length ? code[pos] : undefined
+
+  let ident: string | null = null
+
+  if (ch !== undefined && /[a-zA-Z_$]/.test(ch)) {
+    // error position is at the start of an identifier
+    const m = code.slice(pos).match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/)
+    if (m) ident = m[0]
+  } else if (ch === undefined || ch === '(') {
+    // end of input or '(' — look backwards for a preceding identifier
+    let end = pos
+    while (end > 0 && /\s/.test(code[end - 1])) end--
+    if (end > 0 && /[a-zA-Z0-9_$]/.test(code[end - 1])) {
+      let start = end
+      while (start > 0 && /[a-zA-Z0-9_$]/.test(code[start - 1])) start--
+      const candidate = code.slice(start, end)
+      if (/^[a-zA-Z_$]/.test(candidate)) ident = candidate
+    }
+  }
+
+  if (ident) return new SyntaxError(`Unexpected identifier '${ident}'`)
+  return err
+}
+
 class Sval {
   static version: string = PkgJson.version
 
@@ -83,7 +110,11 @@ class Sval {
     if (typeof parser === 'function') {
       return parser(code, this.options)
     }
-    return parse(code, this.options)
+    try {
+      return parse(code, this.options)
+    } catch (err) {
+      throw improveSyntaxError(err as SyntaxError & { pos?: number }, code)
+    }
   }
 
   run(code: string | Node) {

tests/expression.test.ts

@@ -530,4 +530,80 @@ describe('testing src/expression.ts', () => {
     `)
     expect(interpreter.exports.sawAssignmentError).toBe(true)
   })
+
+  it('should include full property path in TypeError for non-function member calls (issue #143)', () => {
+    // simple member expression: foo.bar is not a function
+    const interp1 = new Sval()
+    interp1.run(`
+      const foo = { bar: 42 }
+      try {
+        foo.bar()
+      } catch (e) {
+        exports.err = e
+      }
+    `)
+    expect(interp1.exports.err).toBeInstanceOf(TypeError)
+    expect(interp1.exports.err.message).toBe('foo.bar is not a function')
+
+    // nested member expression: foo.bar.baz is not a function
+    const interp2 = new Sval()
+    interp2.run(`
+      const foo = { bar: { baz: 42 } }
+      try {
+        foo.bar.baz()
+      } catch (e) {
+        exports.err = e
+      }
+    `)
+    expect(interp2.exports.err).toBeInstanceOf(TypeError)
+    expect(interp2.exports.err.message).toBe('foo.bar.baz is not a function')
+
+    // computed member expression: foo[0] is not a function
+    const interp3 = new Sval()
+    interp3.run(`
+      const foo = [42]
+      try {
+        foo[0]()
+      } catch (e) {
+        exports.err = e
+      }
+    `)
+    expect(interp3.exports.err).toBeInstanceOf(TypeError)
+    expect(interp3.exports.err.message).toBe('foo[0] is not a function')
+  })
+
+  it('should include identifier name in SyntaxError for invalid async usage (issue #143)', () => {
+    // async followed by identifier that is not a valid async arrow → Unexpected identifier 'name'
+    const sval1 = new Sval()
+    let err1: any
+    try {
+      sval1.run("async fetch('/url')")
+    } catch (e) {
+      err1 = e
+    }
+    expect(err1).toBeInstanceOf(SyntaxError)
+    expect(err1.message).toBe("Unexpected identifier 'fetch'")
+
+    // async followed by bare identifier (no call, just end of input)
+    const sval2 = new Sval()
+    let err2: any
+    try {
+      sval2.run('async foo')
+    } catch (e) {
+      err2 = e
+    }
+    expect(err2).toBeInstanceOf(SyntaxError)
+    expect(err2.message).toBe("Unexpected identifier 'foo'")
+
+    // two identifiers in a row (not async-specific)
+    const sval3 = new Sval()
+    let err3: any
+    try {
+      sval3.run('foo bar')
+    } catch (e) {
+      err3 = e
+    }
+    expect(err3).toBeInstanceOf(SyntaxError)
+    expect(err3.message).toBe("Unexpected identifier 'bar'")
+  })
 })