ether-code 0.9.0 → 0.9.1

package/generators/php-generator.js

@@ -6,6 +6,7 @@ class PHPGenerator {
     this.indent = 0
     this.output = ''
     this.translationMap = {}
+    this.functionMap = {}
     this.supportedLanguages = ['fr', 'en', 'es', 'ru', 'zh', 'ja']
     
     if (i18nPath) {
@@ -21,6 +22,7 @@ class PHPGenerator {
 
   buildTranslationMap() {
     this.translationMap = {}
+    this.functionMap = {}
     
     if (!this.i18n) return
 
@@ -34,6 +36,15 @@ class PHPGenerator {
           const fixed = this.normalizeUTF8(etherWord)
           const normalizedKey = fixed.toLowerCase().trim()
           const cleanPhp = this.cleanPhpValue(phpCode)
+          
+          if (phpCode.endsWith('()')) {
+            this.functionMap[normalizedKey] = cleanPhp
+            const withoutAccents = this.removeAccents(normalizedKey)
+            if (withoutAccents !== normalizedKey) {
+              this.functionMap[withoutAccents] = cleanPhp
+            }
+          }
+          
           this.translationMap[normalizedKey] = cleanPhp
           
           const withoutAccents = this.removeAccents(normalizedKey)
@@ -47,7 +58,6 @@ class PHPGenerator {
 
   normalizeUTF8(str) {
     if (typeof str !== 'string') return String(str)
-    
     try {
       const bytes = new Uint8Array(str.length)
       for (let i = 0; i < str.length; i++) {
@@ -67,8 +77,7 @@ class PHPGenerator {
   }
 
   translate(word) {
-    if (!word) return word
-    if (typeof word !== 'string') return String(word)
+    if (!word || typeof word !== 'string') return word
     
     const normalized = word.toLowerCase().trim()
     
@@ -81,41 +90,35 @@ class PHPGenerator {
       return this.translationMap[withoutAccents]
     }
     
-    if (normalized.includes(' ')) {
-      const words = normalized.split(' ')
-      
-      for (let i = words.length - 1; i >= 1; i--) {
-        const partial = words.slice(0, i + 1).join(' ')
-        if (this.translationMap[partial]) {
-          return this.translationMap[partial]
-        }
-        const partialNoAccent = this.removeAccents(partial)
-        if (this.translationMap[partialNoAccent]) {
-          return this.translationMap[partialNoAccent]
-        }
-      }
-      
-      const firstWord = words[0]
-      if (this.translationMap[firstWord]) {
-        const result = this.translationMap[firstWord]
-        if (!result.startsWith('__') && !result.startsWith('$')) {
-          return result
-        }
-      }
-      const firstWordNoAccent = this.removeAccents(firstWord)
-      if (this.translationMap[firstWordNoAccent]) {
-        const result = this.translationMap[firstWordNoAccent]
-        if (!result.startsWith('__') && !result.startsWith('$')) {
-          return result
-        }
-      }
+    return word
+  }
+
+  translateFunction(word) {
+    if (!word || typeof word !== 'string') return word
+    
+    const normalized = word.toLowerCase().trim()
+    const withoutAccents = this.removeAccents(normalized)
+    
+    if (this.functionMap[normalized]) {
+      return this.functionMap[normalized]
+    }
+    
+    if (this.functionMap[withoutAccents]) {
+      return this.functionMap[withoutAccents]
+    }
+    
+    if (this.translationMap[normalized]) {
+      return this.translationMap[normalized]
+    }
+    
+    if (this.translationMap[withoutAccents]) {
+      return this.translationMap[withoutAccents]
     }
     
     return word
   }
 
   removeAccents(str) {
-    if (typeof str !== 'string') return String(str)
     return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
   }
 
@@ -152,18 +155,16 @@ class PHPGenerator {
 
     const generators = {
       'Program': () => this.generateProgram(node),
-      'DeclareStatement': () => this.generateDeclareStatement(node),
-      'NamespaceDeclaration': () => this.generateNamespaceDeclaration(node),
       'FunctionDeclaration': () => this.generateFunctionDeclaration(node),
       'ClassDeclaration': () => this.generateClassDeclaration(node),
       'InterfaceDeclaration': () => this.generateInterfaceDeclaration(node),
       'TraitDeclaration': () => this.generateTraitDeclaration(node),
       'EnumDeclaration': () => this.generateEnumDeclaration(node),
       'MethodDefinition': () => this.generateMethodDefinition(node),
+      'MethodDeclaration': () => this.generateMethodDefinition(node),
       'PropertyDeclaration': () => this.generatePropertyDeclaration(node),
       'VariableDeclaration': () => this.generateVariableDeclaration(node),
       'ConstantDeclaration': () => this.generateConstantDeclaration(node),
-      'DefineDeclaration': () => this.generateDefineDeclaration(node),
       'IfStatement': () => this.generateIfStatement(node),
       'ForStatement': () => this.generateForStatement(node),
       'ForEachStatement': () => this.generateForEachStatement(node),
@@ -174,6 +175,7 @@ class PHPGenerator {
       'MatchExpression': () => this.generateMatchExpression(node),
       'TryStatement': () => this.generateTryStatement(node),
       'ReturnStatement': () => this.generateReturnStatement(node),
+      'YieldExpression': () => this.generateYieldExpression(node),
       'ThrowStatement': () => this.generateThrowStatement(node),
       'BreakStatement': () => this.writeLine('break;'),
       'ContinueStatement': () => this.writeLine('continue;'),
@@ -182,10 +184,13 @@ class PHPGenerator {
       'PrintStatement': () => this.generatePrintStatement(node),
       'Namespace': () => this.generateNamespace(node),
       'UseStatement': () => this.generateUseStatement(node),
+      'DeclareStatement': () => this.generateDeclareStatement(node),
       'IncludeStatement': () => this.generateIncludeStatement(node),
       'Include': () => this.generateInclude(node),
       'CallExpression': () => this.generateCallExpression(node),
       'MemberExpression': () => this.generateMemberExpression(node),
+      'StaticMemberExpression': () => this.generateStaticMemberExpression(node),
+      'IndexExpression': () => this.generateIndexExpression(node),
       'BinaryExpression': () => this.generateBinaryExpression(node),
       'LogicalExpression': () => this.generateBinaryExpression(node),
       'UnaryExpression': () => this.generateUnaryExpression(node),
@@ -197,19 +202,19 @@ class PHPGenerator {
       'ObjectExpression': () => this.generateObjectExpression(node),
       'ArrowFunction': () => this.generateArrowFunction(node),
       'ArrowFunctionExpression': () => this.generateArrowFunction(node),
+      'FunctionExpression': () => this.generateFunctionExpression(node),
       'Closure': () => this.generateClosure(node),
-      'FunctionExpression': () => this.generateClosure(node),
       'Identifier': () => this.generateIdentifier(node),
-      'Variable': () => this.generateVariable(node),
+      'ThisExpression': () => '$this',
       'Literal': () => this.generateLiteral(node),
-      'StringLiteral': () => this.generateStringLiteral(node),
+      'StringLiteral': () => this.generateLiteral(node),
+      'NumericLiteral': () => this.generateLiteral(node),
+      'BooleanLiteral': () => this.generateLiteral(node),
+      'NullLiteral': () => 'null',
       'NewExpression': () => this.generateNewExpression(node),
       'InstanceOf': () => this.generateInstanceOf(node),
       'BlockStatement': () => this.generateBlockStatement(node),
-      'ThisExpression': () => '$this',
-      'StaticMemberExpression': () => this.generateStaticMemberExpression(node),
-      'IndexExpression': () => this.generateIndexExpression(node),
-      'YieldExpression': () => this.generateYieldExpression(node),
+      'NamespaceDeclaration': () => this.generateNamespace(node),
       'EmptyStatement': () => '',
       'Comment': () => ''
     }
@@ -231,40 +236,12 @@ class PHPGenerator {
     }
   }
 
-  generateDeclareStatement(node) {
-    const directives = (node.directives || []).map(d => {
-      const name = this.safeString(d.name)
-      const value = this.generateNode(d.value)
-      return `${name}=${value}`
-    }).join(', ')
-    
-    this.writeLine(`declare(${directives});`)
-    this.writeLine('')
-  }
-
-  generateNamespaceDeclaration(node) {
-    const name = this.safeString(node.name)
-    this.writeLine(`namespace ${name};`)
-    this.writeLine('')
-    
-    if (node.body) {
-      this.generateNode(node.body)
-    }
-  }
-
-  generateDefineDeclaration(node) {
-    const name = this.safeString(node.name)
-    const value = this.generateNode(node.value)
-    this.writeLine(`define('${name}', ${value});`)
-  }
-
   generateFunctionDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name || 'anonymous')
-    const translatedName = this.translate(name)
+    const name = node.name || node.id?.name || 'anonymous'
     const params = this.generateParams(node.params || [])
     const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
     
-    this.writeLine(`function ${translatedName}(${params})${returnType} {`)
+    this.writeLine(`function ${name}(${params})${returnType} {`)
     this.indent++
     this.generateNode(node.body)
     this.indent--
@@ -280,25 +257,20 @@ class PHPGenerator {
         result += this.translate(p.visibility) + ' '
       }
       
-      if (p.readonly) {
-        result += 'readonly '
-      }
-      
-      const typeHint = p.typeHint || (p.type !== 'Parameter' ? p.type : null)
-      if (typeHint && typeHint !== 'Parameter') {
-        result += this.translateType(typeHint) + ' '
+      if (p.typeHint) {
+        result += this.translateType(p.typeHint) + ' '
       }
       
       if (p.variadic) {
         result += '...'
       }
       
-      if (p.byReference || p.reference) {
+      if (p.reference || p.byReference) {
         result += '&'
       }
       
-      const name = this.safeString(p.name || p.id?.name || p)
-      result += '$' + name
+      const name = p.name || p.id?.name || p
+      result += '$' + (typeof name === 'string' ? name : name.name || 'param')
       
       if (p.default !== undefined && p.default !== null) {
         result += ' = ' + this.generateNode(p.default)
@@ -308,18 +280,11 @@ class PHPGenerator {
     }).join(', ')
   }
 
-  safeString(value) {
-    if (typeof value === 'string') return value
-    if (value && typeof value === 'object') {
-      return value.name || value.value || 'unknown'
-    }
-    return String(value || 'unknown')
-  }
-
   translateType(type) {
     if (!type) return ''
     
     if (typeof type === 'string') {
+      const translated = this.translate(type)
       const typeMap = {
         'chaîne': 'string', 'chaine': 'string', 'string': 'string',
         'entier': 'int', 'integer': 'int', 'int': 'int',
@@ -334,50 +299,53 @@ class PHPGenerator {
         'itérable': 'iterable', 'iterable': 'iterable',
         'jamais': 'never', 'never': 'never'
       }
-      const lower = type.toLowerCase()
-      return typeMap[lower] || type
+      return typeMap[translated.toLowerCase()] || typeMap[type.toLowerCase()] || type
     }
     
-    if (type.type === 'TypeHint' && type.types) {
-      const typeStr = type.types.join('|')
-      return (type.nullable ? '?' : '') + typeStr
+    if (type.type === 'TypeHint' && type.types && type.types.length > 0) {
+      const prefix = type.nullable ? '?' : ''
+      if (type.union || type.types.length > 1) {
+        return prefix + type.types.map(t => this.translateType(t)).join('|')
+      }
+      return prefix + this.translateType(type.types[0])
     }
     
-    if (type.union && type.types) {
+    if (type.union) {
       return type.types.map(t => this.translateType(t)).join('|')
     }
     
-    if (type.intersection && type.types) {
+    if (type.intersection) {
       return type.types.map(t => this.translateType(t)).join('&')
     }
     
-    if (type.nullable && type.type) {
+    if (type.nullable) {
       return '?' + this.translateType(type.type)
     }
     
-    if (type.name) {
-      return this.translateType(type.name)
-    }
-    
-    return String(type)
+    return type.name || type
   }
 
   generateClassDeclaration(node) {
     let declaration = ''
     
-    if (node.abstract) declaration += 'abstract '
-    if (node.final) declaration += 'final '
-    if (node.readonly) declaration += 'readonly '
+    const modifiers = node.modifiers || []
+    if (modifiers.includes('abstract') || node.abstract) declaration += 'abstract '
+    if (modifiers.includes('final') || node.final) declaration += 'final '
+    if (modifiers.includes('readonly') || node.readonly) declaration += 'readonly '
     
-    const className = this.safeString(node.name || node.id?.name)
-    declaration += 'class ' + this.translate(className)
+    declaration += 'class ' + (node.name || node.id?.name)
     
-    if (node.extends) {
-      declaration += ' extends ' + this.translate(this.safeString(node.extends))
+    if (node.superClass) {
+      const superName = typeof node.superClass === 'string' ? node.superClass : node.superClass.name
+      declaration += ' extends ' + superName
+    } else if (node.extends) {
+      declaration += ' extends ' + (typeof node.extends === 'string' ? node.extends : node.extends.name)
     }
     
-    if (node.implements && node.implements.length > 0) {
-      declaration += ' implements ' + node.implements.map(i => this.translate(this.safeString(i))).join(', ')
+    if (node.interfaces && node.interfaces.length > 0) {
+      declaration += ' implements ' + node.interfaces.map(i => typeof i === 'string' ? i : i.name).join(', ')
+    } else if (node.implements && node.implements.length > 0) {
+      declaration += ' implements ' + node.implements.map(i => typeof i === 'string' ? i : i.name).join(', ')
     }
     
     this.writeLine(declaration + ' {')
@@ -393,11 +361,10 @@ class PHPGenerator {
   }
 
   generateInterfaceDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    let declaration = 'interface ' + this.translate(name)
+    let declaration = 'interface ' + this.translate(node.name || node.id?.name)
     
     if (node.extends && node.extends.length > 0) {
-      declaration += ' extends ' + node.extends.map(e => this.translate(this.safeString(e))).join(', ')
+      declaration += ' extends ' + node.extends.map(e => this.translate(e)).join(', ')
     }
     
     this.writeLine(declaration + ' {')
@@ -413,8 +380,7 @@ class PHPGenerator {
   }
 
   generateTraitDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    this.writeLine('trait ' + this.translate(name) + ' {')
+    this.writeLine('trait ' + this.translate(node.name || node.id?.name) + ' {')
     this.indent++
     
     for (const member of node.body || node.members || []) {
@@ -427,8 +393,7 @@ class PHPGenerator {
   }
 
   generateEnumDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    let declaration = 'enum ' + this.translate(name)
+    let declaration = 'enum ' + this.translate(node.name || node.id?.name)
     
     if (node.backingType) {
       declaration += ': ' + this.translateType(node.backingType)
@@ -464,16 +429,19 @@ class PHPGenerator {
     if (node.final) declaration += 'final '
     if (node.abstract) declaration += 'abstract '
     
-    const name = this.translateMethodName(this.safeString(node.name || node.key?.name))
+    const name = this.translateMethodName(node.name || node.key?.name)
     const params = this.generateParams(node.params || node.value?.params || [])
     const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
     
-    if (node.abstract) {
+    const body = node.body || node.value?.body
+    const hasEmptyBody = !body || (body.type === 'BlockStatement' && (!body.body || body.body.length === 0))
+    
+    if (node.abstract || hasEmptyBody) {
       this.writeLine(`${declaration}function ${name}(${params})${returnType};`)
     } else {
       this.writeLine(`${declaration}function ${name}(${params})${returnType} {`)
       this.indent++
-      this.generateNode(node.body || node.value?.body)
+      this.generateNode(body)
       this.indent--
       this.writeLine('}')
     }
@@ -527,7 +495,7 @@ class PHPGenerator {
     }
     
     const normalized = name.toLowerCase().trim()
-    return magicMethods[normalized] || this.translate(name)
+    return magicMethods[normalized] || name
   }
 
   generatePropertyDeclaration(node) {
@@ -539,14 +507,16 @@ class PHPGenerator {
     if (node.static) declaration += 'static '
     if (node.readonly) declaration += 'readonly '
     
-    if (node.type) {
-      declaration += this.translateType(node.type) + ' '
+    if (node.typeHint) {
+      declaration += this.translateType(node.typeHint) + ' '
     }
     
-    const name = this.safeString(node.name || node.key?.name)
-    declaration += '$' + this.translate(name)
+    const name = node.name || node.key?.name
+    declaration += '$' + name
     
-    if (node.value !== undefined) {
+    if (node.default !== undefined && node.default !== null) {
+      declaration += ' = ' + this.generateNode(node.default)
+    } else if (node.value !== undefined && node.value !== null) {
       declaration += ' = ' + this.generateNode(node.value)
     }
     
@@ -555,8 +525,8 @@ class PHPGenerator {
 
   generateVariableDeclaration(node) {
     for (const decl of node.declarations || [node]) {
-      const name = this.safeString(decl.name || decl.id?.name || decl.id)
-      const varName = '$' + name
+      const name = decl.name || decl.id?.name || decl.id
+      const varName = '$' + (typeof name === 'string' ? name : name.name || 'var')
       
       if (decl.init !== undefined) {
         const value = this.generateNode(decl.init)
@@ -568,7 +538,7 @@ class PHPGenerator {
   }
 
   generateConstantDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
+    const name = node.name || node.id?.name
     const value = this.generateNode(node.value || node.init)
     
     if (node.classLevel) {
@@ -587,8 +557,8 @@ class PHPGenerator {
     this.indent--
     
     if (node.alternate) {
-      if (node.alternate.type === 'IfStatement') {
-        this.write('} else ')
+      if (node.alternate.type === 'IfStatement' || node.alternate.type === 'ElseIfStatement') {
+        this.write('} else')
         this.generateIfStatement({ ...node.alternate, isElseIf: true })
       } else {
         this.writeLine('} else {')
@@ -616,8 +586,17 @@ class PHPGenerator {
 
   generateForEachStatement(node) {
     const array = this.generateNode(node.array || node.right || node.iterable)
-    const value = this.generateVariable(node.value || node.left || node.valueVar)
-    const key = node.key || node.keyVar ? this.generateVariable(node.key || node.keyVar) + ' => ' : ''
+    
+    const valueNode = node.value || node.left || node.valueVar
+    const value = typeof valueNode === 'string' 
+      ? '$' + valueNode 
+      : this.generateIdentifier(valueNode)
+    
+    let key = ''
+    const keyNode = node.key || node.keyVar
+    if (keyNode) {
+      key = (typeof keyNode === 'string' ? '$' + keyNode : this.generateIdentifier(keyNode)) + ' => '
+    }
 
     this.writeLine(`foreach (${array} as ${key}${value}) {`)
     this.indent++
@@ -692,19 +671,25 @@ class PHPGenerator {
     this.generateNode(node.block)
     this.indent--
 
-    for (const handler of node.handlers || (node.handler ? [node.handler] : [])) {
-      const exceptionType = handler.type || handler.param?.type || 'Exception'
-      const param = handler.param ? this.generateVariable(handler.param) : '$e'
-      this.writeLine(`} catch (${exceptionType} ${param}) {`)
+    const handlers = node.catches || node.handlers || (node.handler ? [node.handler] : [])
+    for (const handler of handlers) {
+      const types = handler.types && handler.types.length > 0 
+        ? handler.types.join(' | ') 
+        : (handler.type || 'Exception')
+      const param = handler.param 
+        ? (typeof handler.param === 'string' ? '$' + handler.param : this.generateIdentifier(handler.param))
+        : '$e'
+      this.writeLine(`} catch (${types} ${param}) {`)
       this.indent++
       this.generateNode(handler.body)
       this.indent--
     }
 
-    if (node.finalizer) {
+    const finallyBlock = node.finally || node.finalizer
+    if (finallyBlock) {
       this.writeLine('} finally {')
       this.indent++
-      this.generateNode(node.finalizer)
+      this.generateNode(finallyBlock)
       this.indent--
     }
 
@@ -720,6 +705,14 @@ class PHPGenerator {
     }
   }
 
+  generateYieldExpression(node) {
+    const arg = node.argument ? this.generateNode(node.argument) : ''
+    if (node.delegate) {
+      return `yield from ${arg}`
+    }
+    return `yield ${arg}`
+  }
+
   generateThrowStatement(node) {
     const arg = this.generateNode(node.argument)
     this.writeLine(`throw ${arg};`)
@@ -742,8 +735,7 @@ class PHPGenerator {
   }
 
   generateNamespace(node) {
-    const name = this.safeString(node.name)
-    this.writeLine(`namespace ${name};`)
+    this.writeLine(`namespace ${node.name};`)
     this.writeLine('')
   }
 
@@ -752,17 +744,25 @@ class PHPGenerator {
     
     if (node.imports && node.imports.length > 0) {
       for (const imp of node.imports) {
-        const path = this.safeString(imp.path)
+        const path = imp.path || imp.name || imp
         const alias = imp.alias ? ' as ' + imp.alias : ''
         this.writeLine(`use ${typePrefix}${path}${alias};`)
       }
     } else {
-      const name = this.safeString(node.name || node.source)
+      const name = node.name || node.source || 'undefined'
       const alias = node.alias ? ' as ' + node.alias : ''
       this.writeLine(`use ${typePrefix}${name}${alias};`)
     }
   }
 
+  generateDeclareStatement(node) {
+    const directives = (node.directives || []).map(d => {
+      const value = typeof d.value === 'object' ? this.generateNode(d.value) : d.value
+      return `${d.name}=${value}`
+    }).join(', ')
+    this.writeLine(`declare(${directives});`)
+  }
+
   generateIncludeStatement(node) {
     const type = node.once 
       ? (node.required ? 'require_once' : 'include_once') 
@@ -783,23 +783,30 @@ class PHPGenerator {
     let callee
     
     if (typeof node.callee === 'string') {
-      callee = this.translate(node.callee)
-    } else if (node.callee && node.callee.type === 'MemberExpression') {
+      callee = this.translateFunction(node.callee)
+    } else if (node.callee.type === 'MemberExpression') {
       callee = this.generateMemberExpression(node.callee)
-    } else if (node.callee && node.callee.type === 'StaticMemberExpression') {
+    } else if (node.callee.type === 'StaticMemberExpression') {
       callee = this.generateStaticMemberExpression(node.callee)
-    } else if (node.callee && node.callee.type === 'Identifier') {
-      const name = this.safeString(node.callee.name)
-      callee = this.translate(name)
+    } else if (node.callee.type === 'Identifier') {
+      const name = node.callee.name
+      const translated = this.translateFunction(name)
+      if (translated !== name) {
+        callee = translated
+      } else if (name.includes(' ')) {
+        callee = name.replace(/ /g, '_')
+      } else {
+        callee = name
+      }
     } else {
       callee = this.generateNode(node.callee)
     }
     
     const args = (node.arguments || []).map(a => {
-      if (a && a.type === 'SpreadElement') {
+      if (a.spread) {
         return '...' + this.generateNode(a.argument || a)
       }
-      if (a && a.type === 'NamedArgument') {
+      if (a.name && a.value) {
         return `${a.name}: ${this.generateNode(a.value)}`
       }
       return this.generateNode(a)
@@ -813,11 +820,18 @@ class PHPGenerator {
     let property
     
     if (typeof node.property === 'string') {
-      property = this.translateMethodName(node.property)
-    } else if (node.property && node.property.name) {
-      property = this.translateMethodName(node.property.name)
-    } else if (node.property && node.property.type === 'Identifier') {
-      property = this.translateMethodName(node.property.name || node.property.value)
+      property = node.property
+    } else if (node.property.type === 'Identifier') {
+      let propName = node.property.name
+      let translated = this.translateFunction(propName)
+      if (translated.includes('->')) {
+        translated = translated.split('->').pop()
+      } else if (translated.includes('::')) {
+        translated = translated.split('::').pop()
+      } else if (translated !== propName && !translated.includes('(')) {
+        translated = propName
+      }
+      property = translated
     } else {
       property = this.generateNode(node.property)
     }
@@ -828,55 +842,35 @@ class PHPGenerator {
     if (node.computed) {
       return `${object}[${property}]`
     }
-    if (node.nullsafe || node.operator === '?->') {
+    if (node.nullSafe) {
       return `${object}?->${property}`
     }
     return `${object}->${property}`
   }
 
-  translateMethodName(name) {
-    if (!name) return name
-    const translated = this.translate(name)
-    if (translated.includes('->')) {
-      const parts = translated.split('->')
-      return parts[parts.length - 1].replace(/\(\)$/, '')
-    }
-    if (translated.includes('::')) {
-      const parts = translated.split('::')
-      return parts[parts.length - 1].replace(/\(\)$/, '')
-    }
-    return translated.replace(/\(\)$/, '')
-  }
-
   generateStaticMemberExpression(node) {
-    const cls = this.generateNode(node.class)
-    let member
-    
-    if (typeof node.member === 'string') {
-      member = node.member
-    } else if (node.member && node.member.name) {
-      member = node.member.name
+    const classNode = node.class || node.object
+    const className = classNode.type === 'Identifier' ? classNode.name : this.generateNode(classNode)
+    
+    const memberNode = node.member || node.property
+    let memberName
+    if (typeof memberNode === 'string') {
+      memberName = memberNode
+    } else if (memberNode.type === 'Identifier') {
+      memberName = this.translateMethodName(memberNode.name)
     } else {
-      member = this.generateNode(node.member)
+      memberName = this.generateNode(memberNode)
     }
     
-    return `${cls}::${member}`
+    return `${className}::${memberName}`
   }
 
   generateIndexExpression(node) {
     const object = this.generateNode(node.object)
-    const index = node.index ? this.generateNode(node.index) : ''
+    const index = this.generateNode(node.index)
     return `${object}[${index}]`
   }
 
-  generateYieldExpression(node) {
-    const argument = node.argument ? this.generateNode(node.argument) : ''
-    if (node.delegate) {
-      return `yield from ${argument}`
-    }
-    return argument ? `yield ${argument}` : 'yield'
-  }
-
   generateBinaryExpression(node) {
     const left = this.generateNode(node.left)
     const right = this.generateNode(node.right)
@@ -893,16 +887,15 @@ class PHPGenerator {
       'fusion null': '??', 'null coalescing': '??'
     }
     
-    const opLower = op ? op.toLowerCase() : op
-    op = opMap[opLower] || op
+    op = opMap[op?.toLowerCase()] || op
 
-    return `${left} ${op} ${right}`
+    const result = `${left} ${op} ${right}`
+    return node.parenthesized ? `(${result})` : result
   }
 
   generateUnaryExpression(node) {
     const argument = this.generateNode(node.argument || node.operand)
-    let op = node.operator
-    if (op === 'non' || op === 'not') op = '!'
+    const op = node.operator === 'non' || node.operator === 'not' ? '!' : node.operator
     
     if (node.prefix !== false) {
       return `${op}${argument}`
@@ -914,7 +907,7 @@ class PHPGenerator {
     const argument = this.generateNode(node.argument || node.operand)
     const op = node.operator
     
-    if (node.prefix !== false) {
+    if (node.prefix) {
       return `${op}${argument}`
     }
     return `${argument}${op}`
@@ -943,9 +936,6 @@ class PHPGenerator {
   generateArrayExpression(node) {
     const elements = (node.elements || []).map(e => {
       if (!e) return 'null'
-      if (e.type === 'SpreadElement') {
-        return '...' + this.generateNode(e.argument || e)
-      }
       if (e.type === 'ArrayElement') {
         if (e.key !== null && e.key !== undefined) {
           const key = this.generateNode(e.key)
@@ -959,6 +949,9 @@ class PHPGenerator {
         const value = this.generateNode(e.value || e)
         return `${key} => ${value}`
       }
+      if (e.spread) {
+        return '...' + this.generateNode(e.argument || e)
+      }
       return this.generateNode(e)
     })
     
@@ -979,68 +972,94 @@ class PHPGenerator {
     return `fn(${params}) => ${body}`
   }
 
-  generateClosure(node) {
+  generateFunctionExpression(node) {
     const params = this.generateParams(node.params || [])
-    const useVars = node.uses && node.uses.length > 0 
-      ? ` use (${node.uses.map(u => (u.byRef ? '&' : '') + '$' + this.translate(this.safeString(u.name || u))).join(', ')})` 
+    const uses = node.uses || node.use || []
+    const useVars = uses.length > 0 
+      ? ` use (${uses.map(u => (u.byReference || u.byRef ? '&' : '') + '$' + (u.name || u)).join(', ')})` 
       : ''
     const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
     
     let result = `function(${params})${useVars}${returnType} {\n`
+    
+    const savedOutput = this.output
+    const savedIndent = this.indent
+    this.output = ''
     this.indent++
     
-    if (node.body && Array.isArray(node.body.body)) {
-      for (const stmt of node.body.body) {
-        result += this.getIndent() + this.generateNode(stmt)
+    const body = node.body
+    if (body && body.type === 'BlockStatement' && body.body) {
+      for (const stmt of body.body) {
+        this.generateNode(stmt)
       }
-    } else if (node.body) {
-      result += this.getIndent() + 'return ' + this.generateNode(node.body) + ';\n'
+    } else if (body) {
+      this.writeLine('return ' + this.generateNode(body) + ';')
     }
     
-    this.indent--
+    const bodyOutput = this.output
+    this.output = savedOutput
+    this.indent = savedIndent
+    
+    result += bodyOutput
     result += this.getIndent() + '}'
     return result
   }
 
-  generateVariable(node) {
-    if (!node) return '$var'
+  generateClosure(node) {
+    const params = this.generateParams(node.params || [])
+    const useVars = node.use && node.use.length > 0 
+      ? ` use (${node.use.map(u => (u.byRef ? '&' : '') + '$' + this.translate(u.name || u)).join(', ')})` 
+      : ''
+    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
+    
+    let result = `function(${params})${useVars}${returnType} {\n`
+    this.indent++
     
-    const name = this.safeString(node.name || node.id?.name || node)
-    const nameStr = String(name)
+    if (Array.isArray(node.body)) {
+      for (const stmt of node.body) {
+        result += this.getIndent() + this.generateNode(stmt)
+      }
+    } else {
+      result += this.getIndent() + 'return ' + this.generateNode(node.body) + ';\n'
+    }
     
-    if (nameStr.startsWith('$')) return nameStr
-    return '$' + nameStr
+    this.indent--
+    result += this.getIndent() + '}'
+    return result
   }
 
   generateIdentifier(node) {
-    if (!node) return '$var'
-    
-    const name = this.safeString(node.name || node.id?.name || node)
-    const nameStr = String(name)
-    
-    if (nameStr.startsWith('$')) return nameStr
+    const name = node.name || node.id?.name || node
+    if (typeof name !== 'string') return '$var'
     
     const keywords = [
       'true', 'false', 'null', 
       'self', 'parent', 'static',
-      'this', '$this'
+      'this', '$this', 'vrai', 'faux', 'nul', 'ceci'
     ]
-    if (keywords.includes(nameStr.toLowerCase())) {
-      if (nameStr.toLowerCase() === 'this') return '$this'
-      return nameStr
+    const lowerName = name.toLowerCase()
+    
+    if (lowerName === 'vrai') return 'true'
+    if (lowerName === 'faux') return 'false'
+    if (lowerName === 'nul') return 'null'
+    if (lowerName === 'ceci' || lowerName === 'this') return '$this'
+    
+    if (keywords.includes(lowerName)) {
+      return name
     }
     
-    if (/^[A-Z]/.test(nameStr)) return nameStr
+    if (name.startsWith('$')) return name
     
-    if (nameStr.includes('(') || nameStr.includes('::')) return nameStr
+    if (/^[A-Z]/.test(name)) return name
+    
+    if (name.includes('(') || name.includes('::') || name.includes('->')) return name
     
     const superglobals = ['_GET', '_POST', '_SERVER', '_SESSION', '_COOKIE', '_FILES', '_REQUEST', '_ENV', 'GLOBALS']
-    const upper = nameStr.toUpperCase()
-    if (superglobals.includes(nameStr) || superglobals.includes(upper)) {
-      return '$' + upper
+    if (superglobals.includes(name) || superglobals.includes(name.toUpperCase())) {
+      return '$' + name.toUpperCase()
     }
     
-    return '$' + nameStr
+    return '$' + name
   }
 
   generateLiteral(node) {
@@ -1060,26 +1079,10 @@ class PHPGenerator {
     return String(node.value)
   }
 
-  generateStringLiteral(node) {
-    const value = node.value || ''
-    const escaped = value
-      .replace(/\\/g, '\\\\')
-      .replace(/"/g, '\\"')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-      .replace(/\t/g, '\\t')
-    return node.doubleQuoted !== false ? `"${escaped}"` : `'${escaped}'`
-  }
-
   generateNewExpression(node) {
-    let callee
-    if (typeof node.callee === 'string') {
-      callee = this.translate(node.callee)
-    } else if (node.callee && node.callee.name) {
-      callee = this.translate(node.callee.name)
-    } else {
-      callee = this.generateNode(node.callee)
-    }
+    const callee = typeof node.callee === 'string'
+      ? this.translate(node.callee)
+      : this.generateNode(node.callee)
     const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
     return `new ${callee}(${args})`
   }