ether-code 0.9.0 → 0.9.2

package/generators/php-generator.js

@@ -5,361 +5,565 @@ class PHPGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
-    this.translationMap = {}
-    this.supportedLanguages = ['fr', 'en', 'es', 'ru', 'zh', 'ja']
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
     }
+    
+    this.buildFunctionMap()
   }
 
   loadI18n(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8')
     this.i18n = JSON.parse(content)
-    this.buildTranslationMap()
   }
 
-  buildTranslationMap() {
-    this.translationMap = {}
-    
-    if (!this.i18n) return
+  normalizeAccents(str) {
+    if (typeof str !== 'string') return String(str)
+    return str.toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .replace(/-/g, ' ')
+      .replace(/_/g, ' ')
+  }
+
+  buildFunctionMap() {
+    this.functionMap = {
+      'est chaine': 'is_string',
+      'est entier': 'is_int',
+      'est flottant': 'is_float',
+      'est tableau': 'is_array',
+      'est booleen': 'is_bool',
+      'est nul': 'is_null',
+      'est null': 'is_null',
+      'est objet': 'is_object',
+      'est numerique': 'is_numeric',
+      'est callable': 'is_callable',
+      'est appelable': 'is_callable',
+      'est ressource': 'is_resource',
+      'est scalaire': 'is_scalar',
+      'est vide': 'empty',
+      'est iterable': 'is_iterable',
+      'est comptable': 'is_countable',
+      'obtenir type': 'gettype',
+      'definir type': 'settype',
+      'valeur entier': 'intval',
+      'valeur entiere': 'intval',
+      'valeur flottant': 'floatval',
+      'valeur chaine': 'strval',
+      'valeur booleen': 'boolval',
+      'longueur': 'strlen',
+      'sous chaine': 'substr',
+      'sous-chaine': 'substr',
+      'position': 'strpos',
+      'remplacer': 'str_replace',
+      'exploser': 'explode',
+      'imploser': 'implode',
+      'majuscules': 'strtoupper',
+      'minuscules': 'strtolower',
+      'couper espaces': 'trim',
+      'rogner': 'trim',
+      'rogner gauche': 'ltrim',
+      'rogner droite': 'rtrim',
+      'repeter': 'str_repeat',
+      'inverser chaine': 'strrev',
+      'remplir': 'str_pad',
+      'remplir gauche': 'str_pad',
+      'compter': 'count',
+      'trier': 'sort',
+      'trier inverse': 'rsort',
+      'trier associatif': 'asort',
+      'trier cles': 'ksort',
+      'inverser': 'array_reverse',
+      'fusionner': 'array_merge',
+      'fusionner tableaux': 'array_merge',
+      'filtrer': 'array_filter',
+      'filtrer tableau': 'array_filter',
+      'mapper': 'array_map',
+      'mapper tableau': 'array_map',
+      'transformer': 'array_map',
+      'reduire': 'array_reduce',
+      'reduire tableau': 'array_reduce',
+      'cles': 'array_keys',
+      'tableau cles': 'array_keys',
+      'valeurs': 'array_values',
+      'tableau valeurs': 'array_values',
+      'pousser': 'array_push',
+      'ajouter': 'array_push',
+      'retirer': 'array_pop',
+      'rechercher': 'array_search',
+      'existe': 'array_key_exists',
+      'cle existe': 'array_key_exists',
+      'dans tableau': 'in_array',
+      'somme': 'array_sum',
+      'somme tableau': 'array_sum',
+      'unique': 'array_unique',
+      'decouper': 'array_slice',
+      'epissure': 'array_splice',
+      'combiner': 'array_combine',
+      'remplir tableau': 'array_fill',
+      'colonne': 'array_column',
+      'compter valeurs': 'array_count_values',
+      'difference': 'array_diff',
+      'intersection': 'array_intersect',
+      'premier': 'reset',
+      'dernier': 'end',
+      'suivant': 'next',
+      'precedent': 'prev',
+      'courant': 'current',
+      'cle courante': 'key',
+      'melanger': 'shuffle',
+      'absolu': 'abs',
+      'plafond': 'ceil',
+      'plancher': 'floor',
+      'arrondir': 'round',
+      'arrondi': 'round',
+      'racine carree': 'sqrt',
+      'puissance': 'pow',
+      'aleatoire': 'rand',
+      'aleatoire entier': 'random_int',
+      'maximum': 'max',
+      'minimum': 'min',
+      'pi': 'pi',
+      'exponentielle': 'exp',
+      'logarithme': 'log',
+      'logarithme10': 'log10',
+      'sinus': 'sin',
+      'cosinus': 'cos',
+      'tangente': 'tan',
+      'formater nombre': 'number_format',
+      'date': 'date',
+      'temps': 'time',
+      'maintenant': 'time',
+      'creer date': 'mktime',
+      'date vers temps': 'strtotime',
+      'formater date': 'date_format',
+      'fichier existe': 'file_exists',
+      'lire fichier': 'file_get_contents',
+      'ecrire fichier': 'file_put_contents',
+      'ouvrir fichier': 'fopen',
+      'fermer fichier': 'fclose',
+      'lire ligne': 'fgets',
+      'ecrire ligne': 'fputs',
+      'est fichier': 'is_file',
+      'est repertoire': 'is_dir',
+      'creer repertoire': 'mkdir',
+      'supprimer fichier': 'unlink',
+      'renommer': 'rename',
+      'copier': 'copy',
+      'taille fichier': 'filesize',
+      'encoder json': 'json_encode',
+      'decoder json': 'json_decode',
+      'json encoder': 'json_encode',
+      'json decoder': 'json_decode',
+      'correspondre': 'preg_match',
+      'regex correspondance': 'preg_match',
+      'regex toutes': 'preg_match_all',
+      'regex remplacer': 'preg_replace',
+      'demarrer session': 'session_start',
+      'detruire session': 'session_destroy',
+      'definir cookie': 'setcookie',
+      'hacher': 'hash',
+      'hacher mot de passe': 'password_hash',
+      'verifier mot de passe': 'password_verify',
+      'md5': 'md5',
+      'sha1': 'sha1',
+      'base64 encoder': 'base64_encode',
+      'base64 decoder': 'base64_decode',
+      'url encoder': 'urlencode',
+      'url decoder': 'urldecode',
+      'htmlentites': 'htmlentities',
+      'html special': 'htmlspecialchars',
+      'enlever balises': 'strip_tags',
+      'echapper': 'addslashes',
+      'preparer': 'prepare',
+      'executer': 'execute',
+      'recuperer': 'fetch',
+      'recuperer tout': 'fetchAll',
+      'nombre lignes': 'rowCount',
+      'dernier id': 'lastInsertId',
+      'afficher info': 'var_dump',
+      'imprimer r': 'print_r',
+      'exporter': 'var_export',
+      'vide': 'empty',
+      'defini': 'isset',
+      'supprimer': 'unset',
+      'sortie': 'exit',
+      'mourir': 'die',
+      'dormir': 'sleep',
+      'micro dormir': 'usleep',
+      'entete': 'header',
+      'en tete': 'header',
+      'rediriger': 'header',
+      'serialiser': 'serialize',
+      'deserialiser': 'unserialize',
+      'formater': 'format',
+      'getmessage': 'getMessage'
+    }
 
-    for (const [sectionName, section] of Object.entries(this.i18n)) {
-      if (sectionName === 'metadata' || typeof section !== 'object') continue
-      
-      for (const lang of this.supportedLanguages) {
-        if (!section[lang]) continue
-        
-        for (const [etherWord, phpCode] of Object.entries(section[lang])) {
-          const fixed = this.normalizeUTF8(etherWord)
-          const normalizedKey = fixed.toLowerCase().trim()
-          const cleanPhp = this.cleanPhpValue(phpCode)
-          this.translationMap[normalizedKey] = cleanPhp
-          
-          const withoutAccents = this.removeAccents(normalizedKey)
-          if (withoutAccents !== normalizedKey) {
-            this.translationMap[withoutAccents] = cleanPhp
-          }
-        }
-      }
+    this.keywordMap = {
+      'variable': '',
+      'constante': 'const',
+      'fonction': 'function',
+      'retourner': 'return',
+      'si': 'if',
+      'sinon': 'else',
+      'sinon si': 'elseif',
+      'pour': 'for',
+      'pour chaque': 'foreach',
+      'tant que': 'while',
+      'faire': 'do',
+      'selon': 'switch',
+      'cas': 'case',
+      'defaut': 'default',
+      'sortir': 'break',
+      'continuer': 'continue',
+      'essayer': 'try',
+      'attraper': 'catch',
+      'finalement': 'finally',
+      'lancer': 'throw',
+      'nouveau': 'new',
+      'nouvelle': 'new',
+      'classe': 'class',
+      'interface': 'interface',
+      'trait': 'trait',
+      'etend': 'extends',
+      'etendre': 'extends',
+      'implemente': 'implements',
+      'implementer': 'implements',
+      'utiliser': 'use',
+      'public': 'public',
+      'publique': 'public',
+      'prive': 'private',
+      'privee': 'private',
+      'protege': 'protected',
+      'protegee': 'protected',
+      'statique': 'static',
+      'final': 'final',
+      'finale': 'final',
+      'abstrait': 'abstract',
+      'abstraite': 'abstract',
+      'constructeur': '__construct',
+      'destructeur': '__destruct',
+      'obtenir': '__get',
+      'definir': '__set',
+      'appeler': '__call',
+      'vers chaine': '__toString',
+      'espace de noms': 'namespace',
+      'comme': 'as',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'rien': 'null',
+      'ceci': '$this',
+      'parent': 'parent',
+      'self': 'self',
+      'soi': 'self',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'egal': '===',
+      'different': '!==',
+      'concatener': '.',
+      'tableau': 'array',
+      'chaine': 'string',
+      'entier': 'int',
+      'flottant': 'float',
+      'booleen': 'bool',
+      'objet': 'object',
+      'vide type': 'void',
+      'void': 'void',
+      'mixte': 'mixed',
+      'afficher': 'echo',
+      'imprimer': 'print',
+      'inclure': 'include',
+      'inclure une fois': 'include_once',
+      'requiert': 'require',
+      'requerir': 'require',
+      'requiert une fois': 'require_once',
+      'requerir une fois': 'require_once',
+      'rendement': 'yield',
+      'rendement de': 'yield from'
     }
   }
 
-  normalizeUTF8(str) {
-    if (typeof str !== 'string') return String(str)
-    
-    try {
-      const bytes = new Uint8Array(str.length)
-      for (let i = 0; i < str.length; i++) {
-        bytes[i] = str.charCodeAt(i)
-      }
-      const decoder = new TextDecoder('utf-8')
-      return decoder.decode(bytes)
-    } catch (e) {
-      return str
-    }
+  translate(word) {
+    if (!word) return word
+    const normalized = this.normalizeAccents(word)
+    return this.functionMap[normalized] || this.keywordMap[normalized] || word
   }
 
-  cleanPhpValue(value) {
-    if (typeof value !== 'string') return value
-    let cleaned = value.replace(/\(\)$/, '')
-    return cleaned
+  translateFunction(word) {
+    if (!word) return word
+    const normalized = this.normalizeAccents(word)
+    return this.functionMap[normalized] || word
   }
 
-  translate(word) {
+  translateKeyword(word) {
     if (!word) return word
-    if (typeof word !== 'string') return String(word)
-    
-    const normalized = word.toLowerCase().trim()
-    
-    if (this.translationMap[normalized]) {
-      return this.translationMap[normalized]
-    }
-    
-    const withoutAccents = this.removeAccents(normalized)
-    if (this.translationMap[withoutAccents]) {
-      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
+    const normalized = this.normalizeAccents(word)
+    return this.keywordMap[normalized] || word
   }
 
-  removeAccents(str) {
-    if (typeof str !== 'string') return String(str)
-    return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  extractTypeName(typeNode) {
+    if (!typeNode) return ''
+    if (typeof typeNode === 'string') return this.translateKeyword(typeNode)
+    if (typeNode.name) return this.translateKeyword(typeNode.name)
+    if (typeNode.type === 'Identifier') return this.translateKeyword(typeNode.name || typeNode.value || '')
+    if (typeNode.value) return this.translateKeyword(typeNode.value)
+    return ''
   }
 
   generate(ast) {
-    this.output = '<?php\n'
+    this.output = ''
     this.indent = 0
-    
-    if (ast.strict) {
-      this.writeLine("declare(strict_types=1);")
-      this.writeLine('')
+
+    if (ast.phpTag !== false) {
+      this.output = '<?php\n'
     }
 
-    if (Array.isArray(ast.body)) {
-      for (const node of ast.body) {
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
         this.generateNode(node)
       }
-    } else if (ast.body) {
-      this.generateNode(ast.body)
-    } else {
+    } else if (ast && ast.type === 'Program') {
+      for (const node of ast.body || []) {
+        this.generateNode(node)
+      }
+    } else if (ast && ast.type) {
       this.generateNode(ast)
+    } else if (ast && ast.body) {
+      for (const node of ast.body) {
+        this.generateNode(node)
+      }
     }
 
-    return this.output
+    return this.output.trim()
   }
 
   generateNode(node) {
     if (!node) return ''
 
-    if (Array.isArray(node)) {
-      return node.map(n => this.generateNode(n)).join('')
+    switch (node.type) {
+      case 'Program':
+        for (const stmt of node.body || []) {
+          this.generateNode(stmt)
+        }
+        return ''
+      case 'DeclareStatement':
+        return this.generateDeclareStatement(node)
+      case 'NamespaceDeclaration':
+        return this.generateNamespace(node)
+      case 'UseStatement':
+        return this.generateUseStatement(node)
+      case 'ConstantDeclaration':
+        return this.generateConstantDeclaration(node)
+      case 'VariableDeclaration':
+        return this.generateVariableDeclaration(node)
+      case 'FunctionDeclaration':
+        return this.generateFunctionDeclaration(node)
+      case 'ClassDeclaration':
+        return this.generateClassDeclaration(node)
+      case 'InterfaceDeclaration':
+        return this.generateInterfaceDeclaration(node)
+      case 'TraitDeclaration':
+        return this.generateTraitDeclaration(node)
+      case 'EnumDeclaration':
+        return this.generateEnumDeclaration(node)
+      case 'IfStatement':
+        return this.generateIfStatement(node)
+      case 'ForStatement':
+        return this.generateForStatement(node)
+      case 'ForEachStatement':
+        return this.generateForEachStatement(node)
+      case 'WhileStatement':
+        return this.generateWhileStatement(node)
+      case 'DoWhileStatement':
+        return this.generateDoWhileStatement(node)
+      case 'SwitchStatement':
+        return this.generateSwitchStatement(node)
+      case 'TryStatement':
+        return this.generateTryStatement(node)
+      case 'ReturnStatement':
+        return this.generateReturnStatement(node)
+      case 'ThrowStatement':
+        return this.generateThrowStatement(node)
+      case 'BreakStatement':
+        this.writeLine('break;')
+        return ''
+      case 'ContinueStatement':
+        this.writeLine('continue;')
+        return ''
+      case 'ExpressionStatement':
+        return this.generateExpressionStatement(node)
+      case 'EchoStatement':
+        return this.generateEchoStatement(node)
+      case 'BlockStatement':
+        return this.generateBlockStatement(node)
+      case 'CallExpression':
+        return this.generateCallExpression(node)
+      case 'MemberExpression':
+        return this.generateMemberExpression(node)
+      case 'StaticMemberExpression':
+        return this.generateStaticMemberExpression(node)
+      case 'BinaryExpression':
+        return this.generateBinaryExpression(node)
+      case 'LogicalExpression':
+        return this.generateBinaryExpression(node)
+      case 'AssignmentExpression':
+        return this.generateAssignmentExpression(node)
+      case 'UnaryExpression':
+        return this.generateUnaryExpression(node)
+      case 'UpdateExpression':
+        return this.generateUpdateExpression(node)
+      case 'ConditionalExpression':
+        return this.generateConditionalExpression(node)
+      case 'ArrayExpression':
+        return this.generateArrayExpression(node)
+      case 'ObjectExpression':
+        return this.generateObjectExpression(node)
+      case 'Identifier':
+        return this.generateIdentifier(node)
+      case 'Variable':
+        return this.generateVariable(node)
+      case 'Literal':
+        return this.generateLiteral(node)
+      case 'StringLiteral':
+        return this.generateStringLiteral(node)
+      case 'NewExpression':
+        return this.generateNewExpression(node)
+      case 'ThisExpression':
+        return '$this'
+      case 'FunctionExpression':
+        return this.generateFunctionExpression(node)
+      case 'ArrowFunctionExpression':
+        return this.generateArrowFunctionExpression(node)
+      case 'IndexExpression':
+        return this.generateIndexExpression(node)
+      case 'NullCoalesceExpression':
+        return this.generateNullCoalesceExpression(node)
+      case 'YieldExpression':
+        return this.generateYieldExpression(node)
+      default:
+        return ''
     }
+  }
 
-    const type = node.type || node.nodeType
-
-    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),
-      '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),
-      'ForeachStatement': () => this.generateForEachStatement(node),
-      'WhileStatement': () => this.generateWhileStatement(node),
-      'DoWhileStatement': () => this.generateDoWhileStatement(node),
-      'SwitchStatement': () => this.generateSwitchStatement(node),
-      'MatchExpression': () => this.generateMatchExpression(node),
-      'TryStatement': () => this.generateTryStatement(node),
-      'ReturnStatement': () => this.generateReturnStatement(node),
-      'ThrowStatement': () => this.generateThrowStatement(node),
-      'BreakStatement': () => this.writeLine('break;'),
-      'ContinueStatement': () => this.writeLine('continue;'),
-      'ExpressionStatement': () => this.generateExpressionStatement(node),
-      'EchoStatement': () => this.generateEchoStatement(node),
-      'PrintStatement': () => this.generatePrintStatement(node),
-      'Namespace': () => this.generateNamespace(node),
-      'UseStatement': () => this.generateUseStatement(node),
-      'IncludeStatement': () => this.generateIncludeStatement(node),
-      'Include': () => this.generateInclude(node),
-      'CallExpression': () => this.generateCallExpression(node),
-      'MemberExpression': () => this.generateMemberExpression(node),
-      'BinaryExpression': () => this.generateBinaryExpression(node),
-      'LogicalExpression': () => this.generateBinaryExpression(node),
-      'UnaryExpression': () => this.generateUnaryExpression(node),
-      'AssignmentExpression': () => this.generateAssignmentExpression(node),
-      'UpdateExpression': () => this.generateUpdateExpression(node),
-      'ConditionalExpression': () => this.generateConditionalExpression(node),
-      'NullCoalescing': () => this.generateNullCoalescing(node),
-      'ArrayExpression': () => this.generateArrayExpression(node),
-      'ObjectExpression': () => this.generateObjectExpression(node),
-      'ArrowFunction': () => this.generateArrowFunction(node),
-      'ArrowFunctionExpression': () => this.generateArrowFunction(node),
-      'Closure': () => this.generateClosure(node),
-      'FunctionExpression': () => this.generateClosure(node),
-      'Identifier': () => this.generateIdentifier(node),
-      'Variable': () => this.generateVariable(node),
-      'Literal': () => this.generateLiteral(node),
-      'StringLiteral': () => this.generateStringLiteral(node),
-      '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),
-      'EmptyStatement': () => '',
-      'Comment': () => ''
+  generateDeclareStatement(node) {
+    const directives = []
+    if (node.strictTypes) {
+      directives.push('strict_types=1')
     }
-
-    if (generators[type]) {
-      return generators[type]()
+    if (node.ticks) {
+      directives.push(`ticks=${node.ticks}`)
     }
-
-    if (node.expression) {
-      return this.generateNode(node.expression)
+    if (node.encoding) {
+      directives.push(`encoding='${node.encoding}'`)
+    }
+    if (directives.length > 0) {
+      this.writeLine(`declare(${directives.join(', ')});`)
     }
+    return ''
+  }
 
+  generateNamespace(node) {
+    const name = node.name || node.path
+    this.writeLine(`namespace ${name};`)
+    this.writeLine('')
     return ''
   }
 
-  generateProgram(node) {
-    for (const stmt of node.body || []) {
-      this.generateNode(stmt)
-    }
+  generateUseStatement(node) {
+    const name = node.name || node.source
+    const alias = node.alias ? ` as ${node.alias}` : ''
+    this.writeLine(`use ${name}${alias};`)
+    return ''
   }
 
-  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('')
+  generateConstantDeclaration(node) {
+    const name = node.name || node.id?.name
+    const value = this.generateNode(node.value || node.init)
+    this.writeLine(`define('${name}', ${value});`)
+    return ''
   }
 
-  generateNamespaceDeclaration(node) {
-    const name = this.safeString(node.name)
-    this.writeLine(`namespace ${name};`)
-    this.writeLine('')
+  generateVariableDeclaration(node) {
+    const declarations = node.declarations || [node]
     
-    if (node.body) {
-      this.generateNode(node.body)
+    for (const decl of declarations) {
+      const name = this.generateVariable(decl.id || decl)
+      if (decl.init) {
+        const init = this.generateNode(decl.init)
+        this.writeLine(`${name} = ${init};`)
+      }
     }
-  }
-
-  generateDefineDeclaration(node) {
-    const name = this.safeString(node.name)
-    const value = this.generateNode(node.value)
-    this.writeLine(`define('${name}', ${value});`)
+    return ''
   }
 
   generateFunctionDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name || 'anonymous')
-    const translatedName = this.translate(name)
-    const params = this.generateParams(node.params || [])
-    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
+    const name = node.name || node.id?.name || ''
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    let returnType = ''
     
-    this.writeLine(`function ${translatedName}(${params})${returnType} {`)
+    if (node.returnType) {
+      const type = this.extractTypeName(node.returnType)
+      if (type) returnType = ': ' + type
+    }
+
+    this.writeLine(`function ${name}(${params})${returnType} {`)
     this.indent++
-    this.generateNode(node.body)
+    
+    if (node.body) {
+      this.generateBody(node.body)
+    }
+    
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateParams(params) {
-    return params.map(p => {
-      let result = ''
-      
-      if (p.visibility) {
-        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.variadic) {
-        result += '...'
-      }
-      
-      if (p.byReference || p.reference) {
-        result += '&'
-      }
-      
-      const name = this.safeString(p.name || p.id?.name || p)
-      result += '$' + name
-      
-      if (p.default !== undefined && p.default !== null) {
-        result += ' = ' + this.generateNode(p.default)
-      }
-      
-      return result
-    }).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 ''
+  generateParam(param) {
+    let result = ''
     
-    if (typeof type === 'string') {
-      const typeMap = {
-        'chaîne': 'string', 'chaine': 'string', 'string': 'string',
-        'entier': 'int', 'integer': 'int', 'int': 'int',
-        'flottant': 'float', 'float': 'float',
-        'booléen': 'bool', 'booleen': 'bool', 'boolean': 'bool', 'bool': 'bool',
-        'tableau': 'array', 'array': 'array',
-        'objet': 'object', 'object': 'object',
-        'nul': 'null', 'null': 'null',
-        'vide': 'void', 'void': 'void',
-        'mixte': 'mixed', 'mixed': 'mixed',
-        'appelable': 'callable', 'callable': 'callable',
-        'itérable': 'iterable', 'iterable': 'iterable',
-        'jamais': 'never', 'never': 'never'
+    if (param.typeHint || (param.type && param.type !== 'Parameter' && param.type !== 'Identifier')) {
+      const type = param.typeHint || param.type
+      if (typeof type === 'string' && type !== 'Parameter' && type !== 'Identifier') {
+        result += this.translateKeyword(type) + ' '
+      } else if (type && type.name) {
+        result += this.translateKeyword(type.name) + ' '
       }
-      const lower = type.toLowerCase()
-      return typeMap[lower] || type
     }
     
-    if (type.type === 'TypeHint' && type.types) {
-      const typeStr = type.types.join('|')
-      return (type.nullable ? '?' : '') + typeStr
+    if (param.reference) {
+      result += '&'
     }
     
-    if (type.union && type.types) {
-      return type.types.map(t => this.translateType(t)).join('|')
+    if (param.variadic) {
+      result += '...'
     }
     
-    if (type.intersection && type.types) {
-      return type.types.map(t => this.translateType(t)).join('&')
-    }
+    result += this.generateVariable(param)
     
-    if (type.nullable && type.type) {
-      return '?' + this.translateType(type.type)
+    if (param.default !== undefined && param.default !== null) {
+      result += ' = ' + this.generateNode(param.default)
     }
     
-    if (type.name) {
-      return this.translateType(type.name)
+    return result
+  }
+
+  generateBody(body) {
+    if (Array.isArray(body)) {
+      for (const stmt of body) {
+        this.generateNode(stmt)
+      }
+    } else if (body && body.body) {
+      for (const stmt of body.body) {
+        this.generateNode(stmt)
+      }
+    } else if (body) {
+      this.generateNode(body)
     }
-    
-    return String(type)
   }
 
   generateClassDeclaration(node) {
@@ -369,237 +573,210 @@ class PHPGenerator {
     if (node.final) declaration += 'final '
     if (node.readonly) declaration += 'readonly '
     
-    const className = this.safeString(node.name || node.id?.name)
-    declaration += 'class ' + this.translate(className)
-    
-    if (node.extends) {
-      declaration += ' extends ' + this.translate(this.safeString(node.extends))
+    declaration += 'class ' + (node.name || node.id?.name || '')
+
+    if (node.extends || node.superClass) {
+      declaration += ' extends ' + (node.extends || node.superClass)
     }
-    
+
     if (node.implements && node.implements.length > 0) {
-      declaration += ' implements ' + node.implements.map(i => this.translate(this.safeString(i))).join(', ')
+      declaration += ' implements ' + node.implements.join(', ')
     }
-    
+
     this.writeLine(declaration + ' {')
     this.indent++
-    
-    for (const member of node.body || node.members || []) {
-      this.generateNode(member)
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateClassMember(member)
     }
-    
+
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateInterfaceDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    let declaration = 'interface ' + this.translate(name)
+  generateClassMember(node) {
+    if (!node) return
+
+    if (node.type === 'UseTraitStatement') {
+      this.writeLine(`use ${node.traits.join(', ')};`)
+      return
+    }
+
+    const visibility = node.visibility || 'public'
+    const isStatic = node.static ? 'static ' : ''
+    const isReadonly = node.readonly ? 'readonly ' : ''
     
+    if (node.type === 'Property' || node.kind === 'property' || node.type === 'PropertyDeclaration') {
+      const name = '$' + (node.name || node.key?.name || node.id?.name || '')
+      let typeHint = ''
+      if (node.typeHint) {
+        typeHint = this.translateKeyword(node.typeHint) + ' '
+      }
+      const value = node.value ? ' = ' + this.generateNode(node.value) : ''
+      this.writeLine(`${visibility} ${isStatic}${isReadonly}${typeHint}${name}${value};`)
+    } else if (node.type === 'Method' || node.kind === 'method' || node.type === 'MethodDeclaration') {
+      const name = node.name || node.key?.name || ''
+      const translatedName = this.translateKeyword(name)
+      const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+      let returnType = ''
+      
+      if (node.returnType) {
+        const type = this.extractTypeName(node.returnType)
+        if (type) returnType = ': ' + type
+      }
+      
+      const abstractMod = node.abstract ? 'abstract ' : ''
+      
+      if (node.abstract) {
+        this.writeLine(`${abstractMod}${visibility} ${isStatic}function ${translatedName}(${params})${returnType};`)
+      } else {
+        this.writeLine(`${visibility} ${isStatic}function ${translatedName}(${params})${returnType} {`)
+        this.indent++
+        
+        if (node.body) {
+          this.generateBody(node.body)
+        }
+        
+        this.indent--
+        this.writeLine('}')
+      }
+      this.writeLine('')
+    }
+  }
+
+  generateInterfaceDeclaration(node) {
+    let declaration = 'interface ' + (node.name || '')
+
     if (node.extends && node.extends.length > 0) {
-      declaration += ' extends ' + node.extends.map(e => this.translate(this.safeString(e))).join(', ')
+      declaration += ' extends ' + node.extends.join(', ')
     }
-    
+
     this.writeLine(declaration + ' {')
     this.indent++
-    
-    for (const member of node.body || node.members || []) {
-      this.generateNode(member)
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateInterfaceMember(member)
     }
-    
+
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateTraitDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    this.writeLine('trait ' + this.translate(name) + ' {')
-    this.indent++
+  generateInterfaceMember(node) {
+    if (!node) return
+
+    const visibility = 'public'
+    const name = node.name || node.key?.name || ''
+    const translatedName = this.translateKeyword(name)
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    let returnType = ''
     
-    for (const member of node.body || node.members || []) {
-      this.generateNode(member)
+    if (node.returnType) {
+      const type = this.extractTypeName(node.returnType)
+      if (type) returnType = ': ' + type
     }
     
-    this.indent--
-    this.writeLine('}')
+    this.writeLine(`${visibility} function ${translatedName}(${params})${returnType};`)
     this.writeLine('')
   }
 
-  generateEnumDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    let declaration = 'enum ' + this.translate(name)
-    
-    if (node.backingType) {
-      declaration += ': ' + this.translateType(node.backingType)
-    }
-    
-    this.writeLine(declaration + ' {')
+  generateTraitDeclaration(node) {
+    this.writeLine('trait ' + (node.name || '') + ' {')
     this.indent++
-    
-    for (const member of node.cases || node.members || []) {
-      if (member.value !== undefined) {
-        this.writeLine(`case ${member.name} = ${this.generateNode(member.value)};`)
-      } else {
-        this.writeLine(`case ${member.name};`)
-      }
-    }
-    
-    for (const method of node.methods || []) {
-      this.generateNode(method)
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateClassMember(member)
     }
-    
+
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateMethodDefinition(node) {
-    let declaration = ''
-    
-    const visibility = node.visibility || node.access || 'public'
-    declaration += this.translate(visibility) + ' '
-    
-    if (node.static) declaration += 'static '
-    if (node.final) declaration += 'final '
-    if (node.abstract) declaration += 'abstract '
-    
-    const name = this.translateMethodName(this.safeString(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) {
-      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.indent--
-      this.writeLine('}')
-    }
-    this.writeLine('')
-  }
-
-  translateMethodName(name) {
-    if (!name) return 'method'
+  generateEnumDeclaration(node) {
+    let declaration = 'enum ' + (node.name || '')
     
-    const magicMethods = {
-      'constructeur': '__construct',
-      'constructor': '__construct',
-      'destructeur': '__destruct',
-      'destructor': '__destruct',
-      'obtenir': '__get',
-      'get': '__get',
-      'définir': '__set',
-      'definir': '__set',
-      'set': '__set',
-      'appeler': '__call',
-      'call': '__call',
-      'appeler statique': '__callStatic',
-      'call static': '__callStatic',
-      'vers chaîne': '__toString',
-      'vers chaine': '__toString',
-      'to string': '__toString',
-      'invoquer': '__invoke',
-      'invoke': '__invoke',
-      'cloner': '__clone',
-      'clone': '__clone',
-      'dormir': '__sleep',
-      'sleep': '__sleep',
-      'réveiller': '__wakeup',
-      'reveiller': '__wakeup',
-      'wakeup': '__wakeup',
-      'sérialiser': '__serialize',
-      'serialiser': '__serialize',
-      'serialize': '__serialize',
-      'désérialiser': '__unserialize',
-      'deserialiser': '__unserialize',
-      'unserialize': '__unserialize',
-      'isset': '__isset',
-      'existe propriété': '__isset',
-      'existe propriete': '__isset',
-      'unset': '__unset',
-      'détruire propriété': '__unset',
-      'detruire propriete': '__unset',
-      'déboguer info': '__debugInfo',
-      'deboguer info': '__debugInfo',
-      'debug info': '__debugInfo'
+    if (node.backingType) {
+      declaration += ': ' + this.translateKeyword(node.backingType)
     }
-    
-    const normalized = name.toLowerCase().trim()
-    return magicMethods[normalized] || this.translate(name)
-  }
 
-  generatePropertyDeclaration(node) {
-    let declaration = ''
-    
-    const visibility = node.visibility || node.access || 'public'
-    declaration += this.translate(visibility) + ' '
-    
-    if (node.static) declaration += 'static '
-    if (node.readonly) declaration += 'readonly '
-    
-    if (node.type) {
-      declaration += this.translateType(node.type) + ' '
-    }
-    
-    const name = this.safeString(node.name || node.key?.name)
-    declaration += '$' + this.translate(name)
-    
-    if (node.value !== undefined) {
-      declaration += ' = ' + this.generateNode(node.value)
-    }
-    
-    this.writeLine(declaration + ';')
-  }
+    this.writeLine(declaration + ' {')
+    this.indent++
 
-  generateVariableDeclaration(node) {
-    for (const decl of node.declarations || [node]) {
-      const name = this.safeString(decl.name || decl.id?.name || decl.id)
-      const varName = '$' + name
-      
-      if (decl.init !== undefined) {
-        const value = this.generateNode(decl.init)
-        this.writeLine(`${varName} = ${value};`)
+    const cases = node.cases || node.members || []
+    for (const caseNode of cases) {
+      if (caseNode.value !== undefined) {
+        this.writeLine(`case ${caseNode.name} = ${this.generateNode(caseNode.value)};`)
       } else {
-        this.writeLine(`${varName} = null;`)
+        this.writeLine(`case ${caseNode.name};`)
       }
     }
-  }
 
-  generateConstantDeclaration(node) {
-    const name = this.safeString(node.name || node.id?.name)
-    const value = this.generateNode(node.value || node.init)
-    
-    if (node.classLevel) {
-      const visibility = node.visibility ? this.translate(node.visibility) + ' ' : ''
-      this.writeLine(`${visibility}const ${name.toUpperCase()} = ${value};`)
-    } else {
-      this.writeLine(`define('${name.toUpperCase()}', ${value});`)
-    }
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+    return ''
   }
 
   generateIfStatement(node) {
-    const test = this.generateNode(node.test || node.condition)
+    const test = this.generateNode(node.test)
     this.writeLine(`if (${test}) {`)
     this.indent++
-    this.generateNode(node.consequent)
+    this.generateBody(node.consequent)
     this.indent--
-    
+
     if (node.alternate) {
       if (node.alternate.type === 'IfStatement') {
-        this.write('} else ')
-        this.generateIfStatement({ ...node.alternate, isElseIf: true })
+        const altTest = this.generateNode(node.alternate.test)
+        this.writeLine(`} elseif (${altTest}) {`)
+        this.indent++
+        this.generateBody(node.alternate.consequent)
+        this.indent--
+        if (node.alternate.alternate) {
+          this.generateElse(node.alternate.alternate)
+        } else {
+          this.writeLine('}')
+        }
       } else {
         this.writeLine('} else {')
         this.indent++
-        this.generateNode(node.alternate)
+        this.generateBody(node.alternate)
         this.indent--
         this.writeLine('}')
       }
     } else {
       this.writeLine('}')
     }
+    return ''
+  }
+
+  generateElse(node) {
+    if (node.type === 'IfStatement') {
+      const altTest = this.generateNode(node.test)
+      this.writeLine(`} elseif (${altTest}) {`)
+      this.indent++
+      this.generateBody(node.consequent)
+      this.indent--
+      if (node.alternate) {
+        this.generateElse(node.alternate)
+      } else {
+        this.writeLine('}')
+      }
+    } else {
+      this.writeLine('} else {')
+      this.indent++
+      this.generateBody(node)
+      this.indent--
+      this.writeLine('}')
+    }
   }
 
   generateForStatement(node) {
@@ -609,39 +786,43 @@ class PHPGenerator {
 
     this.writeLine(`for (${init}; ${test}; ${update}) {`)
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
     this.writeLine('}')
+    return ''
   }
 
   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 array = this.generateNode(node.array || node.right)
+    const value = this.generateVariable(node.value || node.left)
+    const key = node.key ? this.generateVariable(node.key) + ' => ' : ''
 
     this.writeLine(`foreach (${array} as ${key}${value}) {`)
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
     this.writeLine('}')
+    return ''
   }
 
   generateWhileStatement(node) {
-    const test = this.generateNode(node.test || node.condition)
+    const test = this.generateNode(node.test)
     this.writeLine(`while (${test}) {`)
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
     this.writeLine('}')
+    return ''
   }
 
   generateDoWhileStatement(node) {
     this.writeLine('do {')
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
-    const test = this.generateNode(node.test || node.condition)
+    const test = this.generateNode(node.test)
     this.writeLine(`} while (${test});`)
+    return ''
   }
 
   generateSwitchStatement(node) {
@@ -665,50 +846,35 @@ class PHPGenerator {
 
     this.indent--
     this.writeLine('}')
-  }
-
-  generateMatchExpression(node) {
-    const subject = this.generateNode(node.subject || node.discriminant)
-    let result = `match (${subject}) {\n`
-    
-    for (const arm of node.arms || node.cases || []) {
-      this.indent++
-      if (arm.conditions) {
-        const conditions = arm.conditions.map(c => this.generateNode(c)).join(', ')
-        result += this.getIndent() + `${conditions} => ${this.generateNode(arm.body)},\n`
-      } else if (arm.default) {
-        result += this.getIndent() + `default => ${this.generateNode(arm.body)},\n`
-      }
-      this.indent--
-    }
-    
-    result += this.getIndent() + '}'
-    return result
+    return ''
   }
 
   generateTryStatement(node) {
     this.writeLine('try {')
     this.indent++
-    this.generateNode(node.block)
+    this.generateBody(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'
+    if (node.handler) {
+      const exceptionType = node.handler.exceptionType || node.handler.type || 'Exception'
+      const param = node.handler.param 
+        ? this.generateVariable(node.handler.param) 
+        : '$e'
       this.writeLine(`} catch (${exceptionType} ${param}) {`)
       this.indent++
-      this.generateNode(handler.body)
+      this.generateBody(node.handler.body)
       this.indent--
     }
 
     if (node.finalizer) {
       this.writeLine('} finally {')
       this.indent++
-      this.generateNode(node.finalizer)
+      this.generateBody(node.finalizer)
       this.indent--
     }
 
     this.writeLine('}')
+    return ''
   }
 
   generateReturnStatement(node) {
@@ -718,93 +884,50 @@ class PHPGenerator {
     } else {
       this.writeLine('return;')
     }
+    return ''
   }
 
   generateThrowStatement(node) {
     const arg = this.generateNode(node.argument)
     this.writeLine(`throw ${arg};`)
+    return ''
   }
 
   generateExpressionStatement(node) {
     const expr = this.generateNode(node.expression)
-    this.writeLine(`${expr};`)
+    if (expr) {
+      this.writeLine(`${expr};`)
+    }
+    return ''
   }
 
   generateEchoStatement(node) {
-    const exprs = node.expressions || node.arguments || [node.argument]
-    const args = exprs.filter(Boolean).map(a => this.generateNode(a)).join(', ')
+    const args = (node.expressions || node.arguments || [node.argument]).filter(Boolean).map(a => this.generateNode(a)).join(', ')
     this.writeLine(`echo ${args};`)
+    return ''
   }
 
-  generatePrintStatement(node) {
-    const arg = this.generateNode(node.argument)
-    this.writeLine(`print ${arg};`)
-  }
-
-  generateNamespace(node) {
-    const name = this.safeString(node.name)
-    this.writeLine(`namespace ${name};`)
-    this.writeLine('')
-  }
-
-  generateUseStatement(node) {
-    const typePrefix = node.useType === 'function' ? 'function ' : (node.useType === 'const' ? 'const ' : '')
-    
-    if (node.imports && node.imports.length > 0) {
-      for (const imp of node.imports) {
-        const path = this.safeString(imp.path)
-        const alias = imp.alias ? ' as ' + imp.alias : ''
-        this.writeLine(`use ${typePrefix}${path}${alias};`)
-      }
-    } else {
-      const name = this.safeString(node.name || node.source)
-      const alias = node.alias ? ' as ' + node.alias : ''
-      this.writeLine(`use ${typePrefix}${name}${alias};`)
-    }
-  }
-
-  generateIncludeStatement(node) {
-    const type = node.once 
-      ? (node.required ? 'require_once' : 'include_once') 
-      : (node.required ? 'require' : 'include')
-    const path = typeof node.path === 'string' ? `'${node.path}'` : this.generateNode(node.path)
-    this.writeLine(`${type} ${path};`)
-  }
-
-  generateInclude(node) {
-    if (node.resolved && node.children) {
-      for (const child of node.children) {
-        this.generateNode(child)
-      }
+  generateBlockStatement(node) {
+    for (const stmt of node.body || []) {
+      this.generateNode(stmt)
     }
+    return ''
   }
 
   generateCallExpression(node) {
     let callee
     
     if (typeof node.callee === 'string') {
-      callee = this.translate(node.callee)
-    } else if (node.callee && node.callee.type === 'MemberExpression') {
-      callee = this.generateMemberExpression(node.callee)
-    } else if (node.callee && 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)
+      callee = this.translateFunction(node.callee)
+    } else if (node.callee.type === 'Identifier') {
+      callee = this.translateFunction(node.callee.name)
+    } else if (node.callee.type === 'MemberExpression' || node.callee.type === 'StaticMemberExpression') {
+      callee = this.generateNode(node.callee)
     } else {
       callee = this.generateNode(node.callee)
     }
     
-    const args = (node.arguments || []).map(a => {
-      if (a && a.type === 'SpreadElement') {
-        return '...' + this.generateNode(a.argument || a)
-      }
-      if (a && a.type === 'NamedArgument') {
-        return `${a.name}: ${this.generateNode(a.value)}`
-      }
-      return this.generateNode(a)
-    }).join(', ')
-    
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
     return `${callee}(${args})`
   }
 
@@ -813,118 +936,69 @@ 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') {
+      property = this.translateFunction(node.property.name)
     } else {
       property = this.generateNode(node.property)
     }
     
-    if (node.static) {
-      return `${object}::${property}`
-    }
+    const operator = node.nullsafe ? '?->' : '->'
+    
     if (node.computed) {
       return `${object}[${property}]`
     }
-    if (node.nullsafe || node.operator === '?->') {
-      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(/\(\)$/, '')
+    return `${object}${operator}${property}`
   }
 
   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
-    } else {
-      member = this.generateNode(node.member)
-    }
-    
+    const cls = node.class?.name || this.generateNode(node.class)
+    let member = node.member?.name || this.generateNode(node.member)
+    member = this.translateKeyword(member)
     return `${cls}::${member}`
   }
 
-  generateIndexExpression(node) {
-    const object = this.generateNode(node.object)
-    const index = node.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)
     let op = node.operator
 
     const opMap = {
-      'et': '&&', 'and': '&&',
-      'ou': '||', 'or': '||',
-      'non': '!', 'not': '!',
-      'égal': '===', 'egal': '===', 'equal': '===',
-      'différent': '!==', 'different': '!==', 'not equal': '!==',
-      'concaténer': '.', 'concatener': '.', 'concatenate': '.',
-      'vaisseau spatial': '<=>', 'spaceship': '<=>',
-      'fusion null': '??', 'null coalescing': '??'
+      'et': '&&',
+      'ou': '||',
+      'concatener': '.',
+      'concat': '.'
     }
-    
-    const opLower = op ? op.toLowerCase() : op
-    op = opMap[opLower] || op
+    op = opMap[this.normalizeAccents(op)] || op
+
+    return `${left} ${op} ${right}`
+  }
 
+  generateAssignmentExpression(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    const op = node.operator || '='
     return `${left} ${op} ${right}`
   }
 
   generateUnaryExpression(node) {
-    const argument = this.generateNode(node.argument || node.operand)
-    let op = node.operator
-    if (op === 'non' || op === 'not') op = '!'
+    const operand = this.generateNode(node.operand || node.argument)
+    const op = node.operator === 'non' ? '!' : node.operator
     
     if (node.prefix !== false) {
-      return `${op}${argument}`
+      return `${op}${operand}`
     }
-    return `${argument}${op}`
+    return `${operand}${op}`
   }
 
   generateUpdateExpression(node) {
-    const argument = this.generateNode(node.argument || node.operand)
+    const operand = this.generateNode(node.operand || node.argument)
     const op = node.operator
     
-    if (node.prefix !== false) {
-      return `${op}${argument}`
+    if (node.prefix) {
+      return `${op}${operand}`
     }
-    return `${argument}${op}`
-  }
-
-  generateAssignmentExpression(node) {
-    const left = this.generateNode(node.left)
-    const right = this.generateNode(node.right)
-    const op = node.operator || '='
-    return `${left} ${op} ${right}`
+    return `${operand}${op}`
   }
 
   generateConditionalExpression(node) {
@@ -934,27 +1008,20 @@ class PHPGenerator {
     return `${test} ? ${consequent} : ${alternate}`
   }
 
-  generateNullCoalescing(node) {
-    const left = this.generateNode(node.left)
-    const right = this.generateNode(node.right)
-    return `${left} ?? ${right}`
-  }
-
   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) {
+        if (e.key) {
           const key = this.generateNode(e.key)
           const value = this.generateNode(e.value)
           return `${key} => ${value}`
         }
         return this.generateNode(e.value)
       }
-      if (e.key !== undefined && e.key !== null) {
+      if (e.type === 'SpreadElement') {
+        return '...' + this.generateNode(e.argument)
+      }
+      if (e.key) {
         const key = this.generateNode(e.key)
         const value = this.generateNode(e.value || e)
         return `${key} => ${value}`
@@ -973,86 +1040,44 @@ class PHPGenerator {
     return this.generateArrayExpression(node)
   }
 
-  generateArrowFunction(node) {
-    const params = this.generateParams(node.params || [])
-    const body = this.generateNode(node.body)
-    return `fn(${params}) => ${body}`
-  }
-
-  generateClosure(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 returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
+  generateIdentifier(node) {
+    const name = node.name || node
+    if (typeof name !== 'string') return '$var'
     
-    let result = `function(${params})${useVars}${returnType} {\n`
-    this.indent++
+    const normalized = this.normalizeAccents(name)
     
-    if (node.body && Array.isArray(node.body.body)) {
-      for (const stmt of node.body.body) {
-        result += this.getIndent() + this.generateNode(stmt)
-      }
-    } else if (node.body) {
-      result += this.getIndent() + 'return ' + this.generateNode(node.body) + ';\n'
+    if (this.functionMap[normalized]) {
+      return this.functionMap[normalized]
     }
     
-    this.indent--
-    result += this.getIndent() + '}'
-    return result
-  }
-
-  generateVariable(node) {
-    if (!node) return '$var'
+    const translated = this.translateKeyword(name)
     
-    const name = this.safeString(node.name || node.id?.name || node)
-    const nameStr = String(name)
+    if (translated.startsWith('$')) return translated
+    if (['true', 'false', 'null', 'self', 'parent', 'static'].includes(translated)) {
+      return translated
+    }
+    if (/^[A-Z]/.test(translated)) return translated
+    if (translated === name && !name.startsWith('$')) {
+      return '$' + name
+    }
     
-    if (nameStr.startsWith('$')) return nameStr
-    return '$' + nameStr
+    return translated.startsWith('$') ? translated : '$' + translated
   }
 
-  generateIdentifier(node) {
+  generateVariable(node) {
     if (!node) return '$var'
     
-    const name = this.safeString(node.name || node.id?.name || node)
-    const nameStr = String(name)
+    const name = node.name || node.id?.name || node
+    if (typeof name !== 'string') return '$var'
     
-    if (nameStr.startsWith('$')) return nameStr
-    
-    const keywords = [
-      'true', 'false', 'null', 
-      'self', 'parent', 'static',
-      'this', '$this'
-    ]
-    if (keywords.includes(nameStr.toLowerCase())) {
-      if (nameStr.toLowerCase() === 'this') return '$this'
-      return nameStr
-    }
-    
-    if (/^[A-Z]/.test(nameStr)) return nameStr
-    
-    if (nameStr.includes('(') || nameStr.includes('::')) return nameStr
-    
-    const superglobals = ['_GET', '_POST', '_SERVER', '_SESSION', '_COOKIE', '_FILES', '_REQUEST', '_ENV', 'GLOBALS']
-    const upper = nameStr.toUpperCase()
-    if (superglobals.includes(nameStr) || superglobals.includes(upper)) {
-      return '$' + upper
-    }
-    
-    return '$' + nameStr
+    if (name.startsWith('$')) return name
+    return '$' + name
   }
 
   generateLiteral(node) {
-    if (node.raw !== undefined) return node.raw
+    if (node.raw) return node.raw
     if (typeof node.value === 'string') {
-      const escaped = node.value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t')
-      return `"${escaped}"`
+      return `"${node.value.replace(/"/g, '\\"')}"`
     }
     if (node.value === null) return 'null'
     if (node.value === true) return 'true'
@@ -1061,22 +1086,17 @@ class PHPGenerator {
   }
 
   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}'`
+    const quote = node.doubleQuoted ? '"' : "'"
+    const value = node.value.replace(new RegExp(quote, 'g'), '\\' + quote)
+    return `${quote}${value}${quote}`
   }
 
   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)
+      callee = node.callee
+    } else if (node.callee.type === 'Identifier') {
+      callee = node.callee.name
     } else {
       callee = this.generateNode(node.callee)
     }
@@ -1084,20 +1104,64 @@ class PHPGenerator {
     return `new ${callee}(${args})`
   }
 
-  generateInstanceOf(node) {
+  generateFunctionExpression(node) {
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    
+    let uses = ''
+    if (node.uses && node.uses.length > 0) {
+      const useVars = node.uses.map(u => {
+        const ref = u.byRef ? '&' : ''
+        return ref + this.generateVariable(u)
+      }).join(', ')
+      uses = ` use (${useVars})`
+    }
+    
+    let returnType = ''
+    if (node.returnType) {
+      returnType = ': ' + this.translateKeyword(node.returnType)
+    }
+    
+    let body = ''
+    if (node.body) {
+      const savedOutput = this.output
+      const savedIndent = this.indent
+      this.output = ''
+      this.indent = 0
+      this.generateBody(node.body)
+      body = this.output
+      this.output = savedOutput
+      this.indent = savedIndent
+    }
+    
+    return `function(${params})${uses}${returnType} {\n${body}}`
+  }
+
+  generateArrowFunctionExpression(node) {
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    const body = this.generateNode(node.body)
+    return `fn(${params}) => ${body}`
+  }
+
+  generateIndexExpression(node) {
+    const object = this.generateNode(node.object)
+    const index = node.index ? this.generateNode(node.index) : ''
+    return `${object}[${index}]`
+  }
+
+  generateNullCoalesceExpression(node) {
     const left = this.generateNode(node.left)
     const right = this.generateNode(node.right)
-    return `${left} instanceof ${right}`
+    return `${left} ?? ${right}`
   }
 
-  generateBlockStatement(node) {
-    for (const stmt of node.body || []) {
-      this.generateNode(stmt)
+  generateYieldExpression(node) {
+    if (node.delegate) {
+      return `yield from ${this.generateNode(node.argument)}`
     }
-  }
-
-  write(text) {
-    this.output += text
+    if (node.argument) {
+      return `yield ${this.generateNode(node.argument)}`
+    }
+    return 'yield'
   }
 
   writeLine(text) {
@@ -1109,4 +1173,6 @@ class PHPGenerator {
   }
 }
 
-module.exports = { PHPGenerator }
+module.exports = {
+  PHPGenerator
+}