tjs-lang 0.6.44 → 0.7.3

package/src/lang/parser-transforms.ts

@@ -539,11 +539,31 @@ export function insertAsiProtection(source: string): string {
 
   const lines = source.split('\n')
   const result: string[] = []
+  let inBlockComment = false
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]
     const prevLine = i > 0 ? lines[i - 1] : ''
 
+    // Track block comment state
+    if (inBlockComment) {
+      result.push(line)
+      if (line.includes('*/')) inBlockComment = false
+      continue
+    }
+
+    // Check if this line opens a block comment
+    const commentOpen = line.indexOf('/*')
+    const commentClose = line.indexOf('*/')
+    if (
+      commentOpen !== -1 &&
+      (commentClose === -1 || commentClose < commentOpen)
+    ) {
+      inBlockComment = true
+      result.push(line)
+      continue
+    }
+
     // Check if this line starts with a problematic character
     if (i > 0 && continuationStarts.test(line)) {
       // Get the previous line without trailing comment
@@ -3109,3 +3129,238 @@ export function validateNoEval(source: string): string {
 
   return source
 }
+
+/**
+ * Transform bang access (!.) to __tjs.bang() calls.
+ *
+ * x!.foo       → __tjs.bang(x,'foo')
+ * x.y!.foo     → __tjs.bang(x.y,'foo')
+ * fn()!.foo    → __tjs.bang(fn(),'foo')
+ * arr[0]!.foo  → __tjs.bang(arr[0],'foo')
+ * x!.foo!.bar  → __tjs.bang(__tjs.bang(x,'foo'),'bar')
+ *
+ * If the source is null/undefined, returns MonadicError.
+ * If the source is a MonadicError, propagates it.
+ * Otherwise, performs a bare property access (throws as usual).
+ */
+export function transformBangAccess(source: string): string {
+  // Quick bail — no !. in source at all
+  if (!source.includes('!.')) return source
+
+  let result = ''
+  let i = 0
+
+  // State tracking for strings/comments
+  type State =
+    | 'normal'
+    | 'string-single'
+    | 'string-double'
+    | 'string-template'
+    | 'line-comment'
+    | 'block-comment'
+  let state: State = 'normal'
+  let templateDepth = 0
+
+  while (i < source.length) {
+    const ch = source[i]
+    const next = source[i + 1]
+
+    // State transitions
+    if (state === 'normal') {
+      if (ch === '/' && next === '/') {
+        state = 'line-comment'
+        result += ch
+        i++
+        continue
+      }
+      if (ch === '/' && next === '*') {
+        state = 'block-comment'
+        result += ch
+        i++
+        continue
+      }
+      if (ch === "'") {
+        state = 'string-single'
+        result += ch
+        i++
+        continue
+      }
+      if (ch === '"') {
+        state = 'string-double'
+        result += ch
+        i++
+        continue
+      }
+      if (ch === '`') {
+        state = 'string-template'
+        templateDepth++
+        result += ch
+        i++
+        continue
+      }
+
+      // Detect bang access: ! followed by . followed by a word char (not digit)
+      if (
+        ch === '!' &&
+        next === '.' &&
+        i + 2 < source.length &&
+        /[a-zA-Z_$]/.test(source[i + 2])
+      ) {
+        // Scan backward in `result` to find the expression start
+        const exprEnd = result.length
+        const exprStart = findExprStartBackward(result)
+
+        if (exprStart < exprEnd) {
+          const expr = result.slice(exprStart)
+          result = result.slice(0, exprStart)
+
+          // Scan forward to capture the property name after !.
+          let j = i + 2
+          while (j < source.length && /[\w$]/.test(source[j])) j++
+          const prop = source.slice(i + 2, j)
+
+          result += `__tjs.bang(${expr},'${prop}')`
+          i = j
+          continue
+        }
+      }
+
+      result += ch
+      i++
+    } else if (state === 'line-comment') {
+      result += ch
+      if (ch === '\n') state = 'normal'
+      i++
+    } else if (state === 'block-comment') {
+      result += ch
+      if (ch === '*' && next === '/') {
+        result += next
+        state = 'normal'
+        i += 2
+      } else {
+        i++
+      }
+    } else if (state === 'string-single') {
+      result += ch
+      if (ch === '\\') {
+        result += next || ''
+        i += 2
+      } else if (ch === "'") {
+        state = 'normal'
+        i++
+      } else {
+        i++
+      }
+    } else if (state === 'string-double') {
+      result += ch
+      if (ch === '\\') {
+        result += next || ''
+        i += 2
+      } else if (ch === '"') {
+        state = 'normal'
+        i++
+      } else {
+        i++
+      }
+    } else if (state === 'string-template') {
+      result += ch
+      if (ch === '\\') {
+        result += next || ''
+        i += 2
+      } else if (ch === '`') {
+        templateDepth--
+        state = templateDepth > 0 ? 'string-template' : 'normal'
+        i++
+      } else if (ch === '$' && next === '{') {
+        result += next
+        i += 2
+        state = 'normal'
+      } else {
+        i++
+      }
+    } else {
+      result += ch
+      i++
+    }
+  }
+
+  return result
+}
+
+/**
+ * Scan backward through `text` to find the start of the expression
+ * that ends at the last character of `text`.
+ *
+ * Handles: identifiers, member chains (. and ?.), function calls (),
+ * computed access [], and nested combinations.
+ */
+function findExprStartBackward(text: string): number {
+  let pos = text.length - 1
+
+  // Skip trailing whitespace
+  while (pos >= 0 && /\s/.test(text[pos])) pos--
+  if (pos < 0) return text.length
+
+  // Walk backward consuming expression parts
+  while (pos >= 0) {
+    const ch = text[pos]
+
+    if (/[\w$]/.test(ch)) {
+      // Identifier — consume word chars
+      while (pos >= 0 && /[\w$]/.test(text[pos])) pos--
+      // Check if preceded by . or ?. (member chain continues)
+      if (pos >= 0 && text[pos] === '.') {
+        if (pos >= 1 && text[pos - 1] === '?') {
+          pos -= 2
+        } else {
+          pos--
+        }
+        continue
+      }
+      return pos + 1
+    } else if (ch === ')') {
+      pos = findMatchingOpen(text, pos, '(', ')')
+      if (pos < 0) return 0
+      pos--
+      if (pos >= 0 && /[\w$]/.test(text[pos])) continue
+      if (pos >= 0 && text[pos] === '.') {
+        if (pos >= 1 && text[pos - 1] === '?') pos -= 2
+        else pos--
+        continue
+      }
+      return pos + 1
+    } else if (ch === ']') {
+      pos = findMatchingOpen(text, pos, '[', ']')
+      if (pos < 0) return 0
+      pos--
+      if (pos >= 0 && /[\w$]/.test(text[pos])) continue
+      if (pos >= 0 && text[pos] === '.') {
+        if (pos >= 1 && text[pos - 1] === '?') pos -= 2
+        else pos--
+        continue
+      }
+      return pos + 1
+    } else {
+      return pos + 1
+    }
+  }
+
+  return 0
+}
+
+/** Find the matching opening bracket/paren scanning backward from `pos`. */
+function findMatchingOpen(
+  text: string,
+  pos: number,
+  open: string,
+  close: string
+): number {
+  let depth = 1
+  pos--
+  while (pos >= 0 && depth > 0) {
+    if (text[pos] === close) depth++
+    else if (text[pos] === open) depth--
+    if (depth > 0) pos--
+  }
+  return pos
+}

package/src/lang/parser.test.ts

@@ -13,12 +13,30 @@ describe('Transpiler', () => {
 
     it('should extract return type annotation', () => {
       const result = preprocess(
-        `function foo(x: 'string') -> { result: 'string' } { }`
+        `function foo(x: 'string'): { result: 'string' } { }`
       )
       expect(result.returnType).toBe(`{ result: 'string' }`)
       expect(result.source).not.toContain('->')
     })
 
+    it('should extract colon-style return type annotation', () => {
+      const result = preprocess(
+        `function foo(x: 'string'): { result: 'string' } { }`
+      )
+      expect(result.returnType).toBe(`{ result: 'string' }`)
+      expect(result.source).not.toContain('): ')
+    })
+
+    it('should extract colon-style return type with safety markers', () => {
+      const safe = preprocess(`function foo(x: 0):? 0 { }`)
+      expect(safe.returnType).toBe('0')
+      expect(safe.returnSafety).toBe('safe')
+
+      const unsafe = preprocess(`function foo(x: 0):! 0 { }`)
+      expect(unsafe.returnType).toBe('0')
+      expect(unsafe.returnSafety).toBe('unsafe')
+    })
+
     it('should handle multiple parameters', () => {
       const result = preprocess(`function foo(a: 'string', b: 0, c = 10) { }`)
       expect(result.source).toContain(`a = 'string'`)
@@ -44,7 +62,7 @@ describe('Transpiler', () => {
 
     it('should handle rest param with array type example', () => {
       const result = preprocess(
-        `function mean(...values: [1.0, 2.0, 3.0]) -> 2.0 { return 0 }`
+        `function mean(...values: [1.0, 2.0, 3.0]): 2.0 { return 0 }`
       )
       expect(result.source).toContain('...values)')
       expect(result.source).not.toContain('[1.0')
@@ -417,20 +435,20 @@ test 'always fails' { throw new Error('intentional') }
     })
 
     it('should generate correct runtime validation for integer', () => {
-      const result = tjs(`function test(n: 1) -> 1 { return n }`)
+      const result = tjs(`function test(n: 1): 1 { return n }`)
       // Should check Number.isInteger
       expect(result.code).toContain('Number.isInteger')
     })
 
     it('should generate correct runtime validation for non-negative-integer', () => {
-      const result = tjs(`function test(n: +1) -> 1 { return n }`)
+      const result = tjs(`function test(n: +1): 1 { return n }`)
       // Should check Number.isInteger AND >= 0
       expect(result.code).toContain('Number.isInteger')
       expect(result.code).toContain('< 0')
     })
 
     it('should validate integer at runtime', () => {
-      const result = tjs(`function check(n: 1) -> 1 { return n }`)
+      const result = tjs(`function check(n: 1): 1 { return n }`)
       const savedTjs = globalThis.__tjs
       globalThis.__tjs = createRuntime()
       try {
@@ -446,7 +464,7 @@ test 'always fails' { throw new Error('intentional') }
     })
 
     it('should validate non-negative-integer at runtime', () => {
-      const result = tjs(`function check(n: +1) -> 1 { return n }`)
+      const result = tjs(`function check(n: +1): 1 { return n }`)
       const savedTjs = globalThis.__tjs
       globalThis.__tjs = createRuntime()
       try {
@@ -466,7 +484,7 @@ test 'always fails' { throw new Error('intentional') }
     })
 
     it('should validate float (number) accepts all numbers at runtime', () => {
-      const result = tjs(`function check(n: 0.0) -> 0.0 { return n }`)
+      const result = tjs(`function check(n: 0.0): 0.0 { return n }`)
       const savedTjs = globalThis.__tjs
       globalThis.__tjs = createRuntime()
       try {
@@ -695,7 +713,7 @@ test 'always fails' { throw new Error('intentional') }
 
         This demonstrates TJS doc comments.
         */
-        function greet(name: 'World') -> '' {
+        function greet(name: 'World'): '' {
           return 'Hello, ' + name + '!'
         }
       `)
@@ -715,7 +733,7 @@ test 'always fails' { throw new Error('intentional') }
 
         \`code example\`
         */
-        function test(x: 0) -> 0 {
+        function test(x: 0): 0 {
           return x
         }
       `)
@@ -730,7 +748,7 @@ test 'always fails' { throw new Error('intentional') }
           Indented content here.
           More indented content.
         */
-        function test(x: 0) -> 0 {
+        function test(x: 0): 0 {
           return x
         }
       `)
@@ -748,7 +766,7 @@ test 'always fails' { throw new Error('intentional') }
         /*#
         TJS doc description
         */
-        function test(x: 0) -> 0 {
+        function test(x: 0): 0 {
           return x
         }
       `)
@@ -768,7 +786,7 @@ test 'always fails' { throw new Error('intentional') }
         /*#
         Function-specific documentation.
         */
-        function test(x: 0) -> 0 {
+        function test(x: 0): 0 {
           return x
         }
       `)
@@ -786,7 +804,7 @@ test 'always fails' { throw new Error('intentional') }
 
         const someVar = 123
 
-        function test(x: 0) -> 0 {
+        function test(x: 0): 0 {
           return x
         }
       `)
@@ -810,6 +828,7 @@ test 'always fails' { throw new Error('intentional') }
       // Classes are not supported in AJS/VM - they're a TJS-only feature
       expect(() =>
         transpile(`
+        TjsCompat
         class Foo {}
       `)
       ).toThrow('Classes are not supported')

package/src/lang/parser.ts

@@ -49,6 +49,7 @@ import {
   validateNoEval,
   validateNoVar,
   transformConstBang,
+  transformBangAccess,
   transformExtensionCalls,
 } from './parser-transforms'
 
@@ -80,19 +81,42 @@ export function preprocess(
   const unsafeFunctions = new Set<string>()
   const safeFunctions = new Set<string>()
 
-  // TJS modes - all default to false (JS-compatible by default)
-  const tjsModes: TjsModes = {
-    tjsEquals: false,
-    tjsClass: false,
-    tjsDate: false,
-    tjsNoeval: false,
-    tjsStandard: false,
-    tjsSafeEval: false,
-    tjsNoVar: false,
+  // Detect whether this source was emitted by fromTS (TS-originated)
+  // The /* tjs <- filename */ annotation is the signal
+  const isFromTS = /\/\*\s*tjs\s*<-\s*\S+\s*\*\//.test(source)
+
+  // Native TJS: all modes ON by default (TJS is its own language)
+  // TS-originated or VM target (AJS): all modes OFF, safety none (JS-compatible)
+  const isCompat = isFromTS || options.vmTarget
+  const tjsModes: TjsModes = isCompat
+    ? {
+        tjsEquals: false,
+        tjsClass: false,
+        tjsDate: false,
+        tjsNoeval: false,
+        tjsStandard: false,
+        tjsSafeEval: false,
+        tjsNoVar: false,
+      }
+    : {
+        tjsEquals: true,
+        tjsClass: true,
+        tjsDate: true,
+        tjsNoeval: true,
+        tjsStandard: true,
+        tjsSafeEval: false, // opt-in only (adds import)
+        tjsNoVar: true,
+      }
+
+  // Safety: native TJS defaults to 'inputs' (runtime default),
+  // TS-originated and VM targets default to 'none'
+  if (isCompat) {
+    moduleSafety = 'none'
   }
 
   // Handle module-level safety directive: safety none | safety inputs | safety all
   // Must be at the start of the file (possibly after comments/whitespace)
+  // Explicit directive always overrides the default
   const safetyMatch = source.match(
     /^(\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*)\s*safety\s+(none|inputs|all)\b/
   )
@@ -106,10 +130,11 @@ export function preprocess(
   }
 
   // Handle TJS mode directives (can appear in any order after safety)
-  // TjsStrict enables all TJS modes
+  // TjsStrict enables all TJS modes (useful for TS-originated code opting in)
+  // TjsCompat disables all TJS modes (useful for native TJS opting out)
   // Individual modes: TjsEquals, TjsClass, TjsDate, TjsNoeval, TjsStandard, TjsSafeEval
   const directivePattern =
-    /^(\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*)\s*(TjsStrict|TjsEquals|TjsClass|TjsDate|TjsNoeval|TjsNoVar|TjsStandard|TjsSafeEval)\b/
+    /^(\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*)\s*(TjsStrict|TjsCompat|TjsEquals|TjsClass|TjsDate|TjsNoeval|TjsNoVar|TjsStandard|TjsSafeEval)\b/
 
   let match
   while ((match = source.match(directivePattern))) {
@@ -123,6 +148,15 @@ export function preprocess(
       tjsModes.tjsNoeval = true
       tjsModes.tjsNoVar = true
       tjsModes.tjsStandard = true
+    } else if (directive === 'TjsCompat') {
+      // Disable all TJS modes (JS-compatible)
+      tjsModes.tjsEquals = false
+      tjsModes.tjsClass = false
+      tjsModes.tjsDate = false
+      tjsModes.tjsNoeval = false
+      tjsModes.tjsNoVar = false
+      tjsModes.tjsStandard = false
+      tjsModes.tjsSafeEval = false
     } else if (directive === 'TjsEquals') {
       tjsModes.tjsEquals = true
     } else if (directive === 'TjsClass') {
@@ -158,6 +192,10 @@ export function preprocess(
   // Must happen before acorn parsing since const! is not valid JS
   source = transformConstBang(source)
 
+  // Transform !. bang access to __tjs.bang() calls
+  // Must happen before acorn parsing since !. is not valid JS
+  source = transformBangAccess(source)
+
   // Transform Is/IsNot infix operators to function calls
   // a Is b -> Is(a, b)
   // a IsNot b -> IsNot(a, b)

package/src/lang/perf.test.ts

@@ -38,7 +38,7 @@ describe('TJS Performance', () => {
       // Create a simple test file
       const testFile = '/tmp/perf-test.tjs'
       const { writeFileSync } = await import('fs')
-      writeFileSync(testFile, `function add(a: 1, b: 2) -> 3 { return a + b }`)
+      writeFileSync(testFile, `function add(a: 1, b: 2): 3 { return a + b }`)
 
       const cliPath = path.join(import.meta.dir, '../cli/tjsx.ts')
 
@@ -120,7 +120,7 @@ describe('TJS Performance', () => {
 
       // TJS transpiled
       const tjsResult = tjs(`
-        function tjsDouble(x: 0) -> 0 {
+        function tjsDouble(x: 0): 0 {
           return x * 2
         }
       `)
@@ -128,7 +128,7 @@ describe('TJS Performance', () => {
 
       // TJS with unsafe (!) - no validation wrapper
       const unsafeResult = tjs(`
-        function unsafeDouble(! x: 0) -> 0 {
+        function unsafeDouble(! x: 0): 0 {
           return x * 2
         }
       `)
@@ -172,7 +172,7 @@ describe('TJS Performance', () => {
 
       // TJS transpiled
       const tjsResult = tjs(`
-        function tjsTransform(x: 0, y: 0) -> { sum: 0, product: 0 } {
+        function tjsTransform(x: 0, y: 0): { sum: 0, product: 0 } {
           return { sum: x + y, product: x * y }
         }
       `)
@@ -182,7 +182,7 @@ describe('TJS Performance', () => {
 
       // TJS with unsafe (!) - no validation wrapper
       const unsafeResult = tjs(`
-        function unsafeTransform(! x: 0, y: 0) -> { sum: 0, product: 0 } {
+        function unsafeTransform(! x: 0, y: 0): { sum: 0, product: 0 } {
           return { sum: x + y, product: x * y }
         }
       `)
@@ -225,7 +225,7 @@ describe('TJS Performance', () => {
 
       // TJS transpiled
       const tjsResult = tjs(`
-        function tjsSum(arr: [0]) -> 0 {
+        function tjsSum(arr: [0]): 0 {
           let sum = 0
           for (const n of arr) sum += n
           return sum
@@ -235,7 +235,7 @@ describe('TJS Performance', () => {
 
       // TJS with unsafe (!) - no validation wrapper
       const unsafeResult = tjs(`
-        function unsafeSum(! arr: [0]) -> 0 {
+        function unsafeSum(! arr: [0]): 0 {
           let sum = 0
           for (const n of arr) sum += n
           return sum
@@ -281,7 +281,7 @@ describe('TJS Performance', () => {
 
       // TJS - loop inside function body
       const tjsResult = tjs(`
-        function tjsIntensive(n: 0) -> 0 {
+        function tjsIntensive(n: 0): 0 {
           let sum = 0
           for (let i = 0; i < n; i++) {
             sum += i * i
@@ -295,7 +295,7 @@ describe('TJS Performance', () => {
 
       // TJS unsafe (!) - no validation wrapper
       const unsafeResult = tjs(`
-        function unsafeIntensive(! n: 0) -> 0 {
+        function unsafeIntensive(! n: 0): 0 {
           let sum = 0
           for (let i = 0; i < n; i++) {
             sum += i * i
@@ -338,7 +338,7 @@ describe('TJS Performance', () => {
     it('should measure error path overhead for try block', () => {
       // TJS try-without-catch converts exceptions to monadic errors
       const tryResult = tjs(`
-        function tryThrow(x: 0) -> 0 {
+        function tryThrow(x: 0): 0 {
           try {
             if (x < 0) throw new Error('negative')
             return x
@@ -456,7 +456,7 @@ describe('TJS Performance', () => {
 
       // TJS unsafe (!) version - no wrapper at all
       const unsafeResult = tjs(`
-        function unsafeAdd(! a: 0, b: 0) -> 0 {
+        function unsafeAdd(! a: 0, b: 0): 0 {
           return a + b
         }
       `)

package/src/lang/roundtrip.test.ts

@@ -47,7 +47,7 @@ function execCode(code: string): any[] {
 describe('TJS roundtrip - code should just work', () => {
   test('basic function with type annotations', () => {
     const source = `
-function add(a: 0, b: 0) -> 0 {
+function add(a: 0, b: 0): 0 {
   return a + b
 }
 console.log(add(2, 3))
@@ -61,7 +61,7 @@ console.log(add(2, 3))
 
   test('template literals (backticks)', () => {
     const source = `
-function greet(name: 'World') -> '' {
+function greet(name: 'World'): '' {
   return \`Hello, \${name}!\`
 }
 console.log(greet('TJS'))
@@ -75,7 +75,7 @@ console.log(greet('TJS'))
 
   test('inline tests execute at transpile time', () => {
     const source = `
-function double(x: 0) -> 0 {
+function double(x: 0): 0 {
   return x * 2
 }