tjs-lang 0.7.6 → 0.7.8

package/src/lang/parser-transforms.ts

@@ -593,6 +593,201 @@ export function insertAsiProtection(source: string): string {
   return result.join('\n')
 }
 
+/**
+ * Replace `typeof X` with `TypeOf(X)` outside string/template/comment/regex bodies.
+ * X may be `ident`, `ident.foo`, `ident?.foo`, etc. Anything that doesn't look
+ * like a simple identifier expression (e.g. `typeof (x + 1)`) is left alone.
+ */
+function transformTypeofKeyword(source: string): string {
+  type Match = { keywordStart: number; operandEnd: number; operand: string }
+  const matches: Match[] = []
+  let i = 0
+  let state: TokenizerState = 'normal'
+  const templateStack: number[] = []
+
+  while (i < source.length) {
+    const char = source[i]
+    const nextChar = source[i + 1]
+
+    switch (state) {
+      case 'single-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === "'") state = 'normal'
+        i++
+        continue
+      case 'double-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '"') state = 'normal'
+        i++
+        continue
+      case 'template-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '$' && nextChar === '{') {
+          i += 2
+          templateStack.push(1)
+          state = 'normal'
+          continue
+        }
+        if (char === '`') state = 'normal'
+        i++
+        continue
+      case 'line-comment':
+        if (char === '\n') state = 'normal'
+        i++
+        continue
+      case 'block-comment':
+        if (char === '*' && nextChar === '/') {
+          i += 2
+          state = 'normal'
+          continue
+        }
+        i++
+        continue
+      case 'regex':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '[') {
+          i++
+          while (i < source.length && source[i] !== ']') {
+            if (source[i] === '\\' && i + 1 < source.length) i += 2
+            else i++
+          }
+          if (i < source.length) i++
+          continue
+        }
+        if (char === '/') {
+          i++
+          while (i < source.length && /[gimsuy]/.test(source[i])) i++
+          state = 'normal'
+          continue
+        }
+        i++
+        continue
+      case 'normal':
+        if (templateStack.length > 0) {
+          if (char === '{') {
+            templateStack[templateStack.length - 1]++
+          } else if (char === '}') {
+            templateStack[templateStack.length - 1]--
+            if (templateStack[templateStack.length - 1] === 0) {
+              templateStack.pop()
+              i++
+              state = 'template-string'
+              continue
+            }
+          }
+        }
+        if (char === "'") {
+          i++
+          state = 'single-string'
+          continue
+        }
+        if (char === '"') {
+          i++
+          state = 'double-string'
+          continue
+        }
+        if (char === '`') {
+          i++
+          state = 'template-string'
+          continue
+        }
+        if (char === '/' && nextChar === '/') {
+          i += 2
+          state = 'line-comment'
+          continue
+        }
+        if (char === '/' && nextChar === '*') {
+          i += 2
+          state = 'block-comment'
+          continue
+        }
+        if (char === '/') {
+          let j = i - 1
+          while (j >= 0 && /\s/.test(source[j])) j--
+          const beforeChar = j >= 0 ? source[j] : ''
+          const isRegexContext =
+            !beforeChar ||
+            /[=(!,;:{[&|?+\-*%<>~^]/.test(beforeChar) ||
+            (j >= 5 &&
+              /\b(return|case|throw|in|of|typeof|instanceof|new|delete|void)$/.test(
+                source.slice(Math.max(0, j - 10), j + 1)
+              ))
+          if (isRegexContext) {
+            i++
+            state = 'regex'
+            continue
+          }
+        }
+
+        // Detect `typeof <ident-chain>` — only when preceded by a non-word
+        // boundary and followed by whitespace then an identifier.
+        if (
+          char === 't' &&
+          source.slice(i, i + 6) === 'typeof' &&
+          (i === 0 || !/[\w$]/.test(source[i - 1])) &&
+          /\s/.test(source[i + 6] ?? '')
+        ) {
+          let j = i + 6
+          while (j < source.length && /\s/.test(source[j])) j++
+          if (j < source.length && /[a-zA-Z_$]/.test(source[j])) {
+            const operandStart = j
+            while (j < source.length && /[\w$]/.test(source[j])) j++
+            // Optional `.name` or `?.name` chains
+            while (j < source.length) {
+              if (source[j] === '.' && /[a-zA-Z_$]/.test(source[j + 1] ?? '')) {
+                j++
+                while (j < source.length && /[\w$]/.test(source[j])) j++
+              } else if (
+                source[j] === '?' &&
+                source[j + 1] === '.' &&
+                /[a-zA-Z_$]/.test(source[j + 2] ?? '')
+              ) {
+                j += 2
+                while (j < source.length && /[\w$]/.test(source[j])) j++
+              } else {
+                break
+              }
+            }
+            matches.push({
+              keywordStart: i,
+              operandEnd: j,
+              operand: source.slice(operandStart, j),
+            })
+            i = j
+            continue
+          }
+        }
+        break
+    }
+    i++
+  }
+
+  if (matches.length === 0) return source
+
+  // Apply replacements from end to start so earlier positions remain valid.
+  let result = source
+  for (let k = matches.length - 1; k >= 0; k--) {
+    const m = matches[k]
+    result =
+      result.slice(0, m.keywordStart) +
+      `TypeOf(${m.operand})` +
+      result.slice(m.operandEnd)
+  }
+  return result
+}
+
 /**
  * Transform == and != to Is() and IsNot() calls
  *
@@ -606,11 +801,11 @@ export function insertAsiProtection(source: string): string {
  * 2. Transform from end to start (so positions remain valid)
  */
 export function transformEqualityToStructural(source: string): string {
-  // Transform typeof to TypeOf() — fixes typeof null === 'object'
-  source = source.replace(
-    /\btypeof\s+([a-zA-Z_$][\w$.]*(?:\?\.[\w$]+)*)/g,
-    'TypeOf($1)'
-  )
+  // Transform typeof to TypeOf() — fixes typeof null === 'object'.
+  // Uses the same tokenizer state machine as the equality pass so it skips
+  // string/template/comment/regex bodies (a regex replace would rewrite
+  // 'typeof x' inside string literals).
+  source = transformTypeofKeyword(source)
 
   // First pass: find all == and != positions (outside strings/comments/regex)
   const equalityOps: Array<{ pos: number; op: '==' | '!=' }> = []
@@ -2642,9 +2837,43 @@ export function extractAndRunTests(
         let depth = 1
         let k = bodyStart
 
-        // Find matching closing brace
+        // Find matching closing brace (skip strings and comments)
+        let inStr: string | null = null
+        let escaped = false
         while (k < source.length && depth > 0) {
           const char = source[k]
+          if (escaped) {
+            escaped = false
+            k++
+            continue
+          }
+          if (char === '\\' && inStr) {
+            escaped = true
+            k++
+            continue
+          }
+          if (inStr) {
+            if (char === inStr) inStr = null
+            k++
+            continue
+          }
+          // Line comment — skip to end of line
+          if (char === '/' && source[k + 1] === '/') {
+            const nl = source.indexOf('\n', k)
+            k = nl === -1 ? source.length : nl + 1
+            continue
+          }
+          // Block comment — skip to */
+          if (char === '/' && source[k + 1] === '*') {
+            const end = source.indexOf('*/', k + 2)
+            k = end === -1 ? source.length : end + 2
+            continue
+          }
+          if (char === "'" || char === '"' || char === '`') {
+            inStr = char
+            k++
+            continue
+          }
           if (char === '{') depth++
           else if (char === '}') depth--
           k++
@@ -3366,3 +3595,307 @@ function findMatchingOpen(
   }
   return pos
 }
+
+/**
+ * Transform `let x: <example>` and `let x: <example> = value` declarations.
+ *
+ * Strips the `: <example>` annotation so Acorn can parse, and records the
+ * variable name + example text so the linter and (later) type inference can
+ * use the annotation. Acorn rejects the colon since it is not valid JS.
+ *
+ *   let x: ''           → let x         (annotation: x → '')
+ *   let x: 0 = 5        → let x = 5     (annotation: x → 0)
+ *   let result: { ok: false } = ...     (annotation: result → { ok: false })
+ *
+ * Only `let` is processed. `const` always has an initializer, so the type
+ * is always inferable. `var` is rejected by TjsNoVar mode.
+ */
+export function transformLetTypeAnnotations(source: string): {
+  source: string
+  annotations: Map<string, string>
+} {
+  const annotations = new Map<string, string>()
+  if (!source.includes('let ')) return { source, annotations }
+
+  type Replacement = { start: number; end: number; replacement: string }
+  const replacements: Replacement[] = []
+
+  let i = 0
+  let state: TokenizerState = 'normal'
+  const templateStack: number[] = []
+
+  while (i < source.length) {
+    const char = source[i]
+    const nextChar = source[i + 1]
+
+    switch (state) {
+      case 'single-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === "'") state = 'normal'
+        i++
+        continue
+      case 'double-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '"') state = 'normal'
+        i++
+        continue
+      case 'template-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '$' && nextChar === '{') {
+          i += 2
+          templateStack.push(1)
+          state = 'normal'
+          continue
+        }
+        if (char === '`') state = 'normal'
+        i++
+        continue
+      case 'line-comment':
+        if (char === '\n') state = 'normal'
+        i++
+        continue
+      case 'block-comment':
+        if (char === '*' && nextChar === '/') {
+          i += 2
+          state = 'normal'
+          continue
+        }
+        i++
+        continue
+      case 'regex':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '[') {
+          i++
+          while (i < source.length && source[i] !== ']') {
+            if (source[i] === '\\' && i + 1 < source.length) i += 2
+            else i++
+          }
+          if (i < source.length) i++
+          continue
+        }
+        if (char === '/') {
+          i++
+          while (i < source.length && /[gimsuy]/.test(source[i])) i++
+          state = 'normal'
+          continue
+        }
+        i++
+        continue
+      case 'normal':
+        if (templateStack.length > 0) {
+          if (char === '{') {
+            templateStack[templateStack.length - 1]++
+          } else if (char === '}') {
+            templateStack[templateStack.length - 1]--
+            if (templateStack[templateStack.length - 1] === 0) {
+              templateStack.pop()
+              i++
+              state = 'template-string'
+              continue
+            }
+          }
+        }
+        if (char === "'") {
+          i++
+          state = 'single-string'
+          continue
+        }
+        if (char === '"') {
+          i++
+          state = 'double-string'
+          continue
+        }
+        if (char === '`') {
+          i++
+          state = 'template-string'
+          continue
+        }
+        if (char === '/' && nextChar === '/') {
+          i += 2
+          state = 'line-comment'
+          continue
+        }
+        if (char === '/' && nextChar === '*') {
+          i += 2
+          state = 'block-comment'
+          continue
+        }
+        if (char === '/') {
+          let j = i - 1
+          while (j >= 0 && /\s/.test(source[j])) j--
+          const beforeChar = j >= 0 ? source[j] : ''
+          const isRegexContext =
+            !beforeChar ||
+            /[=(!,;:{[&|?+\-*%<>~^]/.test(beforeChar) ||
+            (j >= 5 &&
+              /\b(return|case|throw|in|of|typeof|instanceof|new|delete|void)$/.test(
+                source.slice(Math.max(0, j - 10), j + 1)
+              ))
+          if (isRegexContext) {
+            i++
+            state = 'regex'
+            continue
+          }
+        }
+
+        // Detect `let <ident> :` at top-level normal state
+        if (
+          char === 'l' &&
+          source.slice(i, i + 4) === 'let ' &&
+          (i === 0 || !/[\w$]/.test(source[i - 1]))
+        ) {
+          // Skip past `let` and whitespace
+          let j = i + 4
+          while (j < source.length && /\s/.test(source[j])) j++
+          // Match identifier
+          if (j < source.length && /[a-zA-Z_$]/.test(source[j])) {
+            const nameStart = j
+            while (j < source.length && /[\w$]/.test(source[j])) j++
+            const nameEnd = j
+            const varName = source.slice(nameStart, nameEnd)
+            // Skip whitespace; require a `:` (not `::` or part of `?:`)
+            let k = j
+            while (k < source.length && /\s/.test(source[k])) k++
+            if (
+              k < source.length &&
+              source[k] === ':' &&
+              source[k + 1] !== ':'
+            ) {
+              const colonPos = k
+              // Skip whitespace after colon
+              let exStart = colonPos + 1
+              while (exStart < source.length && /[ \t]/.test(source[exStart])) {
+                exStart++
+              }
+              // Scan example expression until `=`, `,`, `;`, or newline at depth 0
+              const exEnd = scanExampleEnd(source, exStart)
+              if (exEnd > exStart) {
+                const example = source.slice(exStart, exEnd).trim()
+                annotations.set(varName, example)
+                replacements.push({
+                  start: nameEnd,
+                  end: exEnd,
+                  replacement: '',
+                })
+                i = exEnd
+                continue
+              }
+            }
+          }
+        }
+        break
+    }
+    i++
+  }
+
+  if (replacements.length === 0) return { source, annotations }
+
+  // Apply right-to-left to preserve positions
+  let result = source
+  for (let k = replacements.length - 1; k >= 0; k--) {
+    const r = replacements[k]
+    result = result.slice(0, r.start) + r.replacement + result.slice(r.end)
+  }
+  return { source: result, annotations }
+}
+
+/**
+ * Scan forward from `start` and return the position where the example
+ * expression ends. Stops at `=`, `,`, `;`, or a newline when paren/brace/
+ * bracket depth is 0. Skips through nested brackets, strings, and templates.
+ */
+function scanExampleEnd(source: string, start: number): number {
+  let i = start
+  let parens = 0
+  let braces = 0
+  let brackets = 0
+  let state: 'normal' | 'sq' | 'dq' | 'tpl' = 'normal'
+  const templateStack: number[] = []
+  while (i < source.length) {
+    const c = source[i]
+    if (state === 'sq') {
+      if (c === '\\') {
+        i += 2
+        continue
+      }
+      if (c === "'") state = 'normal'
+      i++
+      continue
+    }
+    if (state === 'dq') {
+      if (c === '\\') {
+        i += 2
+        continue
+      }
+      if (c === '"') state = 'normal'
+      i++
+      continue
+    }
+    if (state === 'tpl') {
+      if (c === '\\') {
+        i += 2
+        continue
+      }
+      if (c === '$' && source[i + 1] === '{') {
+        templateStack.push(1)
+        state = 'normal'
+        i += 2
+        continue
+      }
+      if (c === '`') state = 'normal'
+      i++
+      continue
+    }
+    // normal
+    if (templateStack.length > 0) {
+      if (c === '{') templateStack[templateStack.length - 1]++
+      else if (c === '}') {
+        templateStack[templateStack.length - 1]--
+        if (templateStack[templateStack.length - 1] === 0) {
+          templateStack.pop()
+          state = 'tpl'
+          i++
+          continue
+        }
+      }
+    }
+    if (c === "'") {
+      state = 'sq'
+      i++
+      continue
+    }
+    if (c === '"') {
+      state = 'dq'
+      i++
+      continue
+    }
+    if (c === '`') {
+      state = 'tpl'
+      i++
+      continue
+    }
+    if (c === '(') parens++
+    else if (c === ')') parens--
+    else if (c === '{') braces++
+    else if (c === '}') braces--
+    else if (c === '[') brackets++
+    else if (c === ']') brackets--
+    if (parens === 0 && braces === 0 && brackets === 0) {
+      if (c === '=' || c === ',' || c === ';' || c === '\n') return i
+    }
+    i++
+  }
+  return i
+}

package/src/lang/parser-types.ts

@@ -144,6 +144,8 @@ export interface TjsModes {
   tjsSafeEval: boolean
   /** TjsNoVar: var declarations are syntax errors */
   tjsNoVar: boolean
+  /** TjsSafeAssign: let declarations need an initializer or `: example` annotation; literal undefined/null/void 0 assigned to typed lets is flagged */
+  tjsSafeAssign: boolean
 }
 
 /**

package/src/lang/parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'bun:test'
 import { transpile, ajs, tjs } from './index'
-import { preprocess } from './parser'
+import { preprocess, parse } from './parser'
 import { createRuntime, isMonadicError } from './runtime'
 
 describe('Transpiler', () => {
@@ -1067,4 +1067,76 @@ test 'always fails' { throw new Error('intentional') }
       expect(varSetStep.value.op).toBe('??')
     })
   })
+
+  describe('stray `=>` on function declarations', () => {
+    it('errors clearly on `function f(...): T => { body }`', () => {
+      // A common mistake — writing arrow-function syntax on a regular
+      // function declaration. Without the dedicated check, the `=>` falls
+      // through to Acorn which complains at a misleading position.
+      expect(() =>
+        tjs(`function f(s: '', n = 0): 0 => {
+  return s.length + n
+}`)
+      ).toThrow(/Unexpected '=>' after function declaration/)
+    })
+
+    it('errors with column pointing at the `=>` (not earlier in the line)', () => {
+      let caught: any
+      try {
+        tjs(`function f(): 0 => { return 0 }`)
+      } catch (e) {
+        caught = e
+      }
+      expect(caught).toBeDefined()
+      // The `=>` is at column 17 (1-indexed): `function f(): 0 ` is 16 chars
+      expect(caught.column).toBe(16)
+    })
+
+    it('does not error on regular function declarations', () => {
+      expect(() =>
+        tjs(`function f(s: ''): 0 { return s.length }`)
+      ).not.toThrow()
+    })
+
+    it('does not error on real arrow function expressions', () => {
+      expect(() => tjs(`const f = (s = '') => s.length`)).not.toThrow()
+    })
+  })
+
+  describe('let type annotations (TjsSafeAssign)', () => {
+    it("strips `: <example>` from `let x: ''` and records annotation", () => {
+      const r = parse(`let x: ''`)
+      expect(r.letAnnotations.get('x')).toBe("''")
+    })
+
+    it('strips `: <example>` from `let x: 0 = 5` and keeps the initializer', () => {
+      const r = parse(`let x: 0 = 5`)
+      expect(r.letAnnotations.get('x')).toBe('0')
+      const decl = r.ast.body[0] as any
+      expect(decl.type).toBe('VariableDeclaration')
+      expect(decl.declarations[0].init).not.toBeNull()
+    })
+
+    it('handles object-literal example with nested braces', () => {
+      const r = parse(
+        `function f() { let result: { ok: false }; return result }`
+      )
+      expect(r.letAnnotations.get('result')).toBe('{ ok: false }')
+    })
+
+    it('does not strip `:` inside string literals', () => {
+      const r = parse(`let s = 'a:b:c'`)
+      expect(r.letAnnotations.size).toBe(0)
+    })
+
+    it('TjsSafeAssign mode is on by default in native TJS', () => {
+      const r = parse(`let x = 0`)
+      expect(r.tjsModes.tjsSafeAssign).toBe(true)
+    })
+
+    it('TjsCompat directive disables TjsSafeAssign', () => {
+      const r = parse(`TjsCompat\nlet x = 0`)
+      expect(r.tjsModes.tjsSafeAssign).toBe(false)
+    })
+  })
 })