ether-code 0.7.8 → 0.8.0

package/generators/php-generator.js

@@ -5,6 +5,8 @@ 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)
@@ -14,447 +16,260 @@ class PHPGenerator {
   loadI18n(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8')
     this.i18n = JSON.parse(content)
-    this.buildMaps()
+    this.buildTranslationMap()
   }
 
-  buildMaps() {
-    this.keywordMap = {}
-    this.functionMap = {}
+  buildTranslationMap() {
+    this.translationMap = {}
     
     if (!this.i18n) return
 
-    const addToMap = (map, section) => {
-      if (!section) return
-      for (const [key, translations] of Object.entries(section)) {
-        if (translations && translations.fr) {
-          map[translations.fr.toLowerCase()] = key
-        }
-      }
-    }
-
-    const addAllSections = (map) => {
-      for (const [sectionName, section] of Object.entries(this.i18n)) {
-        if (typeof section === 'object' && section !== null) {
-          addToMap(map, section)
+    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 normalizedKey = etherWord.toLowerCase().trim()
+          const cleanPhp = this.cleanPhpValue(phpCode)
+          this.translationMap[normalizedKey] = cleanPhp
         }
       }
     }
+  }
 
-    addAllSections(this.keywordMap)
-    addAllSections(this.functionMap)
+  cleanPhpValue(value) {
+    if (typeof value !== 'string') return value
+    let cleaned = value.replace(/\(\)$/, '')
+    return cleaned
   }
 
   translate(word) {
-    const lower = word.toLowerCase()
-    return this.translateGeneric(lower)
-  }
-
-  translateGeneric(word) {
-    const translations = {
-      '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',
-      'classe': 'class',
-      'interface': 'interface',
-      'trait': 'trait',
-      'etend': 'extends',
-      'implemente': 'implements',
-      'utiliser': 'use',
-      'public': 'public',
-      'prive': 'private',
-      'protege': 'protected',
-      'statique': 'static',
-      'final': 'final',
-      'abstrait': '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',
-      'ceci': '$this',
-      'parent': 'parent',
-      'soi': 'self',
-      'et': '&&',
-      'ou': '||',
-      'non': '!',
-      'egal': '===',
-      'different': '!==',
-      'concatener': '.',
-      'tableau': 'array',
-      'chaine': 'string',
-      'entier': 'int',
-      'flottant': 'float',
-      'booleen': 'bool',
-      'objet': 'object',
-      'vide': 'void',
-      'mixte': 'mixed',
-      'afficher': 'echo',
-      'imprimer': 'print',
-      'longueur': 'strlen',
-      'compter': 'count',
-      'exploser': 'explode',
-      'imploser': 'implode',
-      'remplacer': 'str_replace',
-      'position': 'strpos',
-      'sous chaine': 'substr',
-      'majuscules': 'strtoupper',
-      'minuscules': 'strtolower',
-      'supprimer espaces': 'trim',
-      'ajouter': 'array_push',
-      'retirer': 'array_pop',
-      'fusionner': 'array_merge',
-      'filtrer': 'array_filter',
-      'mapper': 'array_map',
-      'reduire': 'array_reduce',
-      'trier': 'sort',
-      'inverser': 'array_reverse',
-      'cles': 'array_keys',
-      'valeurs': 'array_values',
-      'existe': 'isset',
-      'vide test': 'empty',
-      'est tableau': 'is_array',
-      'est chaine': 'is_string',
-      'est entier': 'is_int',
-      'est flottant': 'is_float',
-      'est numerique': 'is_numeric',
-      'est nul': 'is_null',
-      'type de': 'gettype',
-      'convertir chaine': 'strval',
-      'convertir entier': 'intval',
-      'convertir flottant': 'floatval',
-      'convertir booleen': 'boolval',
-      'definir type': 'settype',
-      'date': 'date',
-      'temps': 'time',
-      'maintenant': 'now',
-      'fichier existe': 'file_exists',
-      'lire fichier': 'file_get_contents',
-      'ecrire fichier': 'file_put_contents',
-      'ouvrir': 'fopen',
-      'fermer': 'fclose',
-      'lire': 'fread',
-      'ecrire': 'fwrite',
-      'json encoder': 'json_encode',
-      'json decoder': 'json_decode',
-      'regex correspondance': 'preg_match',
-      'regex toutes': 'preg_match_all',
-      'regex remplacer': 'preg_replace',
-      'en tete': 'header',
-      'rediriger': 'header',
-      'session demarrer': 'session_start',
-      'session': '$_SESSION',
-      'post': '$_POST',
-      'get': '$_GET',
-      'requete': '$_REQUEST',
-      'serveur': '$_SERVER',
-      'fichiers': '$_FILES',
-      'cookie': '$_COOKIE',
-      'mourir': 'die',
-      'sortie': 'exit',
-      'inclure': 'include',
-      'inclure une fois': 'include_once',
-      'requiert': 'require',
-      'requiert une fois': 'require_once',
-      'mapper tableau': 'array_map',
-      'filtrer tableau': 'array_filter',
-      'reduire tableau': 'array_reduce',
-      'parcourir tableau': 'array_walk',
-      'parcourir recursif': 'array_walk_recursive',
-      'decaler tableau': 'array_shift',
-      'depiler tableau': 'array_pop',
-      'empiler tableau': 'array_push',
-      'prefixer tableau': 'array_unshift',
-      'chercher tableau': 'array_search',
-      'cle existe tableau': 'array_key_exists',
-      'dans tableau': 'in_array',
-      'somme tableau': 'array_sum',
-      'produit tableau': 'array_product',
-      'compter valeurs': 'array_count_values',
-      'aleatoire tableau': 'array_rand',
-      'element courant': 'current',
-      'element suivant': 'next',
-      'element precedent': 'prev',
-      'cle courante': 'key',
-      'premier element': 'reset',
-      'dernier element': 'end',
-      'remplir tableau': 'array_fill',
-      'remplir cles tableau': 'array_fill_keys',
-      'rembourrer tableau': 'array_pad',
-      'plage': 'range',
-      'fonction existe': 'function_exists',
-      'classe existe': 'class_exists',
-      'methode existe': 'method_exists',
-      'propriete existe': 'property_exists',
-      'interface existe': 'interface_exists',
-      'trait existe': 'trait_exists',
-      'obtenir classe': 'get_class',
-      'obtenir parent classe': 'get_parent_class',
-      'obtenir methodes classe': 'get_class_methods',
-      'obtenir variables classe': 'get_class_vars',
-      'obtenir variables objet': 'get_object_vars',
-      'est instance de': 'is_a',
-      'est sous-classe de': 'is_subclass_of',
-      'classes declarees': 'get_declared_classes',
-      'interfaces declarees': 'get_declared_interfaces',
-      'traits declares': 'get_declared_traits',
-      'entete http': 'header',
-      'entetes envoyes': 'headers_sent',
-      'liste entetes': 'headers_list',
-      'retirer entete': 'header_remove',
-      'code reponse http': 'http_response_code',
-      'analyser url': 'parse_url',
-      'construire requete http': 'http_build_query',
-      'analyser parametres': 'parse_str',
-      'encoder url': 'urlencode',
-      'decoder url': 'urldecode',
-      'encoder url brut': 'rawurlencode',
-      'decoder url brut': 'rawurldecode',
-      'encoder base64': 'base64_encode',
-      'decoder base64': 'base64_decode',
-      'hacher mot de passe': 'password_hash',
-      'verifier mot de passe': 'password_verify',
-      'rehachage necessaire': 'password_needs_rehash',
-      'info mot de passe': 'password_get_info',
-      'bcrypt par defaut': 'PASSWORD_DEFAULT',
-      'bcrypt': 'PASSWORD_BCRYPT',
-      'argon2i': 'PASSWORD_ARGON2I',
-      'argon2id': 'PASSWORD_ARGON2ID',
-      'appeler fonction utilisateur': 'call_user_func',
-      'appeler avec arguments': 'call_user_func_array',
-      'creer fonction': 'create_function',
-      'filtrer variable': 'filter_var',
-      'filtrer entree': 'filter_input',
-      'filtrer tableau entree': 'filter_input_array',
-      'filtrer tableau variable': 'filter_var_array',
-      'liste filtres': 'filter_list',
-      'id filtre': 'filter_id',
-      'valider email': 'FILTER_VALIDATE_EMAIL',
-      'valider url': 'FILTER_VALIDATE_URL',
-      'valider ip': 'FILTER_VALIDATE_IP',
-      'valider entier': 'FILTER_VALIDATE_INT',
-      'valider flottant': 'FILTER_VALIDATE_FLOAT',
-      'valider booleen': 'FILTER_VALIDATE_BOOLEAN',
-      'nettoyer chaine': 'FILTER_SANITIZE_STRING',
-      'nettoyer email': 'FILTER_SANITIZE_EMAIL',
-      'nettoyer url': 'FILTER_SANITIZE_URL',
-      'nettoyer entier': 'FILTER_SANITIZE_NUMBER_INT',
-      'nettoyer flottant': 'FILTER_SANITIZE_NUMBER_FLOAT',
-      'obtenir config': 'ini_get',
-      'definir config': 'ini_set',
-      'restaurer config': 'ini_restore',
-      'toutes configs': 'ini_get_all',
-      'obtenir environnement': 'getenv',
-      'definir environnement': 'putenv',
-      'version php': 'phpversion',
-      'info php': 'phpinfo',
-      'comparer versions': 'version_compare',
-      'extension chargee': 'extension_loaded',
-      'extensions chargees': 'get_loaded_extensions',
-      'formater chaine': 'sprintf',
-      'afficher formate': 'printf',
-      'formater vers flux': 'fprintf',
-      'formater avec tableau': 'vsprintf',
-      'afficher avec tableau': 'vprintf',
-      'analyser formate': 'sscanf',
-      'formater nombre': 'number_format',
-      'formater monnaie': 'money_format',
-      'ajouter echappements': 'addslashes',
-      'retirer echappements': 'stripslashes',
-      'ajouter echappements c': 'addcslashes',
-      'retirer echappements c': 'stripcslashes',
-      'citer meta': 'quotemeta',
-      'compacter': 'compact',
-      'extraire': 'extract',
-      'variables definies': 'get_defined_vars',
-      'enregistrer autoload': 'spl_autoload_register',
-      'desenregistrer autoload': 'spl_autoload_unregister',
-      'fonctions autoload': 'spl_autoload_functions',
-      'autoload': 'spl_autoload',
-      'extensions autoload': 'spl_autoload_extensions',
-      'hacher': 'hash',
-      'hacher fichier': 'hash_file',
-      'hacher hmac': 'hash_hmac',
-      'algorithmes hachage': 'hash_algos',
-      'md5': 'md5',
-      'md5 fichier': 'md5_file',
-      'sha1': 'sha1',
-      'sha1 fichier': 'sha1_file',
-      'crc32': 'crc32',
-      'octets aleatoires': 'random_bytes',
-      'entier aleatoire': 'random_int',
-      'traduire caracteres': 'strtr',
-      'sous-chaine compte': 'substr_count',
-      'sous-chaine remplacer': 'substr_replace',
-      'comparer sous-chaine': 'substr_compare',
-      'chercher chaine': 'strstr',
-      'chercher insensible': 'stristr',
-      'chercher caractere': 'strchr',
-      'chercher caractere inverse': 'strrchr',
-      'dormir': 'sleep',
-      'dormir micro': 'usleep',
-      'memoire utilisee': 'memory_get_usage',
-      'memoire pic': 'memory_get_peak_usage',
-      'limite memoire': "ini_get('memory_limit')",
-      'chemin inclus': 'get_include_path',
-      'definir chemin inclus': 'set_include_path'
-    }
-
-    const lower = word.toLowerCase()
-    return translations[lower] || word
+    if (!word || typeof word !== 'string') return 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]
+    }
+    
+    return word
+  }
+
+  removeAccents(str) {
+    return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
   }
 
   generate(ast) {
-    this.output = '<?php\n\n'
+    this.output = '<?php\n'
     this.indent = 0
+    
+    if (ast.strict) {
+      this.writeLine("declare(strict_types=1);")
+      this.writeLine('')
+    }
 
-    if (Array.isArray(ast)) {
-      for (const node of ast) {
-        this.generateNode(node)
-      }
-    } else if (ast && ast.type) {
-      this.generateNode(ast)
-    } else if (ast && ast.body) {
+    if (Array.isArray(ast.body)) {
       for (const node of ast.body) {
         this.generateNode(node)
       }
+    } else if (ast.body) {
+      this.generateNode(ast.body)
+    } else {
+      this.generateNode(ast)
     }
 
-    return this.output.trim()
+    return this.output
   }
 
   generateNode(node) {
     if (!node) return ''
 
-    switch (node.type) {
-      case 'VariableDeclaration':
-        return this.generateVariableDeclaration(node)
-      case 'FunctionDeclaration':
-        return this.generateFunctionDeclaration(node)
-      case 'ClassDeclaration':
-        return this.generateClassDeclaration(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 'NamespaceDeclaration':
-        return this.generateNamespace(node)
-      case 'UseStatement':
-        return this.generateUseStatement(node)
-      case 'IncludeStatement':
-        return this.generateIncludeStatement(node)
-      case 'Include':
-        return this.generateInclude(node)
-      case 'CallExpression':
-        return this.generateCallExpression(node)
-      case 'MemberExpression':
-        return this.generateMemberExpression(node)
-      case 'BinaryExpression':
-        return this.generateBinaryExpression(node)
-      case 'AssignmentExpression':
-        return this.generateAssignmentExpression(node)
-      case 'ArrayExpression':
-        return this.generateArrayExpression(node)
-      case 'ObjectExpression':
-        return this.generateObjectExpression(node)
-      case 'Identifier':
-        return this.generateIdentifier(node)
-      case 'Literal':
-        return this.generateLiteral(node)
-      case 'NewExpression':
-        return this.generateNewExpression(node)
-      default:
-        return ''
+    if (Array.isArray(node)) {
+      return node.map(n => this.generateNode(n)).join('')
+    }
+
+    const type = node.type || node.nodeType
+
+    const generators = {
+      'Program': () => this.generateProgram(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),
+      '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),
+      'Closure': () => this.generateClosure(node),
+      'Identifier': () => this.generateIdentifier(node),
+      'Literal': () => this.generateLiteral(node),
+      'NewExpression': () => this.generateNewExpression(node),
+      'InstanceOf': () => this.generateInstanceOf(node),
+      'BlockStatement': () => this.generateBlockStatement(node),
+      'EmptyStatement': () => '',
+      'Comment': () => ''
     }
+
+    if (generators[type]) {
+      return generators[type]()
+    }
+
+    if (node.expression) {
+      return this.generateNode(node.expression)
+    }
+
+    return ''
   }
 
-  generateVariableDeclaration(node) {
-    for (const decl of node.declarations || [node]) {
-      const name = this.generateIdentifier(decl.id || decl.name)
-      if (decl.init) {
-        const value = this.generateNode(decl.init)
-        this.writeLine(`${name} = ${value};`)
-      } else {
-        this.writeLine(`${name} = null;`)
-      }
+  generateProgram(node) {
+    for (const stmt of node.body || []) {
+      this.generateNode(stmt)
     }
   }
 
   generateFunctionDeclaration(node) {
-    const name = node.id ? node.id.name || node.id : node.name
-    const params = (node.params || []).map(p => {
-      let param = this.generateIdentifier(p.name || p)
-      if (p.type) param = p.type + ' ' + param
-      if (p.default) param += ' = ' + this.generateNode(p.default)
-      return param
+    const name = this.translate(node.name || node.id?.name || 'anonymous')
+    const params = this.generateParams(node.params || [])
+    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
+    
+    this.writeLine(`function ${name}(${params})${returnType} {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateParams(params) {
+    return params.map(p => {
+      let result = ''
+      
+      if (p.visibility) {
+        result += this.translate(p.visibility) + ' '
+      }
+      
+      if (p.type) {
+        result += this.translateType(p.type) + ' '
+      }
+      
+      if (p.variadic) {
+        result += '...'
+      }
+      
+      if (p.reference) {
+        result += '&'
+      }
+      
+      const name = p.name || p.id?.name || p
+      result += '$' + this.translate(typeof name === 'string' ? name : name.name || 'param')
+      
+      if (p.default !== undefined) {
+        result += ' = ' + this.generateNode(p.default)
+      }
+      
+      return result
     }).join(', ')
+  }
+
+  translateType(type) {
+    if (!type) return ''
     
-    const returnType = node.returnType ? ': ' + node.returnType : ''
-    const visibility = node.visibility ? node.visibility + ' ' : ''
-    const isStatic = node.static ? 'static ' : ''
+    if (typeof type === 'string') {
+      const translated = this.translate(type)
+      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'
+      }
+      return typeMap[translated.toLowerCase()] || typeMap[type.toLowerCase()] || type
+    }
     
-    this.writeLine(`${visibility}${isStatic}function ${name}(${params})${returnType} {`)
+    if (type.union) {
+      return type.types.map(t => this.translateType(t)).join('|')
+    }
+    
+    if (type.intersection) {
+      return type.types.map(t => this.translateType(t)).join('&')
+    }
+    
+    if (type.nullable) {
+      return '?' + this.translateType(type.type)
+    }
+    
+    return type.name || type
+  }
+
+  generateClassDeclaration(node) {
+    let declaration = ''
+    
+    if (node.abstract) declaration += 'abstract '
+    if (node.final) declaration += 'final '
+    if (node.readonly) declaration += 'readonly '
+    
+    declaration += 'class ' + this.translate(node.name || node.id?.name)
+    
+    if (node.extends) {
+      declaration += ' extends ' + this.translate(node.extends)
+    }
+    
+    if (node.implements && node.implements.length > 0) {
+      declaration += ' implements ' + node.implements.map(i => this.translate(i)).join(', ')
+    }
+    
+    this.writeLine(declaration + ' {')
     this.indent++
     
-    if (node.body) {
-      if (Array.isArray(node.body)) {
-        for (const stmt of node.body) {
-          this.generateNode(stmt)
-        }
-      } else if (node.body.body) {
-        for (const stmt of node.body.body) {
-          this.generateNode(stmt)
-        }
-      } else {
-        this.generateNode(node.body)
-      }
+    for (const member of node.body || node.members || []) {
+      this.generateNode(member)
     }
     
     this.indent--
@@ -462,57 +277,201 @@ class PHPGenerator {
     this.writeLine('')
   }
 
-  generateClassDeclaration(node) {
-    const name = node.id ? node.id.name || node.id : node.name
-    let declaration = 'class ' + name
+  generateInterfaceDeclaration(node) {
+    let declaration = 'interface ' + this.translate(node.name || node.id?.name)
     
-    if (node.superClass) {
-      declaration += ' extends ' + (node.superClass.name || node.superClass)
+    if (node.extends && node.extends.length > 0) {
+      declaration += ' extends ' + node.extends.map(e => this.translate(e)).join(', ')
     }
-    if (node.implements && node.implements.length > 0) {
-      const interfaces = node.implements.map(i => i.name || i).join(', ')
-      declaration += ' implements ' + interfaces
+    
+    this.writeLine(declaration + ' {')
+    this.indent++
+    
+    for (const member of node.body || node.members || []) {
+      this.generateNode(member)
+    }
+    
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateTraitDeclaration(node) {
+    this.writeLine('trait ' + this.translate(node.name || node.id?.name) + ' {')
+    this.indent++
+    
+    for (const member of node.body || node.members || []) {
+      this.generateNode(member)
+    }
+    
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateEnumDeclaration(node) {
+    let declaration = 'enum ' + this.translate(node.name || node.id?.name)
+    
+    if (node.backingType) {
+      declaration += ': ' + this.translateType(node.backingType)
     }
     
     this.writeLine(declaration + ' {')
     this.indent++
     
-    if (node.body) {
-      const body = node.body.body || node.body
-      if (Array.isArray(body)) {
-        for (const member of body) {
-          this.generateNode(member)
-        }
+    for (const member of node.cases || node.members || []) {
+      if (member.value !== undefined) {
+        this.writeLine(`case ${member.name} = ${this.generateNode(member.value)};`)
       } else {
-        this.generateNode(body)
+        this.writeLine(`case ${member.name};`)
       }
     }
     
+    for (const method of node.methods || []) {
+      this.generateNode(method)
+    }
+    
     this.indent--
     this.writeLine('}')
     this.writeLine('')
   }
 
+  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(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'
+    
+    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'
+    }
+    
+    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.translate(node.name || node.key?.name)
+    declaration += '$' + name
+    
+    if (node.value !== undefined) {
+      declaration += ' = ' + this.generateNode(node.value)
+    }
+    
+    this.writeLine(declaration + ';')
+  }
+
+  generateVariableDeclaration(node) {
+    for (const decl of node.declarations || [node]) {
+      const name = decl.name || decl.id?.name || decl.id
+      const varName = '$' + this.translate(typeof name === 'string' ? name : name.name || 'var')
+      
+      if (decl.init !== undefined) {
+        const value = this.generateNode(decl.init)
+        this.writeLine(`${varName} = ${value};`)
+      } else {
+        this.writeLine(`${varName} = null;`)
+      }
+    }
+  }
+
+  generateConstantDeclaration(node) {
+    const name = 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});`)
+    }
+  }
+
   generateIfStatement(node) {
     const test = this.generateNode(node.test)
     this.writeLine(`if (${test}) {`)
     this.indent++
     this.generateNode(node.consequent)
     this.indent--
-
+    
     if (node.alternate) {
       if (node.alternate.type === 'IfStatement') {
-        this.output = this.output.trimEnd() + ' elseif '
-        const altTest = this.generateNode(node.alternate.test)
-        this.output += `(${altTest}) {\n`
-        this.indent++
-        this.generateNode(node.alternate.consequent)
-        this.indent--
-        if (node.alternate.alternate) {
-          this.generateIfStatement({ alternate: node.alternate.alternate })
-        } else {
-          this.writeLine('}')
-        }
+        this.write('} else')
+        this.generateIfStatement({ ...node.alternate, isElseIf: true })
       } else {
         this.writeLine('} else {')
         this.indent++
@@ -538,9 +497,9 @@ class PHPGenerator {
   }
 
   generateForEachStatement(node) {
-    const array = this.generateNode(node.array || node.right)
-    const value = this.generateIdentifier(node.value || node.left)
-    const key = node.key ? this.generateIdentifier(node.key) + ' => ' : ''
+    const array = this.generateNode(node.array || node.right || node.iterable)
+    const value = this.generateIdentifier(node.value || node.left || node.valueVar)
+    const key = node.key || node.keyVar ? this.generateIdentifier(node.key || node.keyVar) + ' => ' : ''
 
     this.writeLine(`foreach (${array} as ${key}${value}) {`)
     this.indent++
@@ -590,18 +549,37 @@ class PHPGenerator {
     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
+  }
+
   generateTryStatement(node) {
     this.writeLine('try {')
     this.indent++
     this.generateNode(node.block)
     this.indent--
 
-    if (node.handler) {
-      const exceptionType = node.handler.type || 'Exception'
-      const param = node.handler.param ? this.generateIdentifier(node.handler.param) : '$e'
+    for (const handler of node.handlers || (node.handler ? [node.handler] : [])) {
+      const exceptionType = handler.type || handler.param?.type || 'Exception'
+      const param = handler.param ? this.generateIdentifier(handler.param) : '$e'
       this.writeLine(`} catch (${exceptionType} ${param}) {`)
       this.indent++
-      this.generateNode(node.handler.body)
+      this.generateNode(handler.body)
       this.indent--
     }
 
@@ -635,10 +613,15 @@ class PHPGenerator {
   }
 
   generateEchoStatement(node) {
-    const args = (node.arguments || [node.argument]).map(a => this.generateNode(a)).join(', ')
+    const args = (node.arguments || [node.argument]).filter(Boolean).map(a => this.generateNode(a)).join(', ')
     this.writeLine(`echo ${args};`)
   }
 
+  generatePrintStatement(node) {
+    const arg = this.generateNode(node.argument)
+    this.writeLine(`print ${arg};`)
+  }
+
   generateNamespace(node) {
     this.writeLine(`namespace ${node.name};`)
     this.writeLine('')
@@ -647,11 +630,14 @@ class PHPGenerator {
   generateUseStatement(node) {
     const name = node.name || node.source
     const alias = node.alias ? ' as ' + node.alias : ''
-    this.writeLine(`use ${name}${alias};`)
+    const type = node.type === 'function' ? 'function ' : (node.type === 'const' ? 'const ' : '')
+    this.writeLine(`use ${type}${name}${alias};`)
   }
 
   generateIncludeStatement(node) {
-    const type = node.once ? (node.required ? 'require_once' : 'include_once') : (node.required ? 'require' : 'include')
+    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};`)
   }
@@ -661,16 +647,30 @@ class PHPGenerator {
       for (const child of node.children) {
         this.generateNode(child)
       }
-    } else {
-      this.writeLine(`// Include non résolu: ${node.path || 'inconnu'}`)
     }
   }
 
   generateCallExpression(node) {
-    const callee = typeof node.callee === 'string' 
-      ? this.translate(node.callee)
-      : this.generateNode(node.callee)
-    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+    let callee
+    
+    if (typeof node.callee === 'string') {
+      callee = this.translate(node.callee)
+    } else if (node.callee.type === 'MemberExpression') {
+      callee = this.generateMemberExpression(node.callee)
+    } else {
+      callee = this.generateNode(node.callee)
+    }
+    
+    const args = (node.arguments || []).map(a => {
+      if (a.spread) {
+        return '...' + this.generateNode(a.argument || a)
+      }
+      if (a.name && a.value) {
+        return `${a.name}: ${this.generateNode(a.value)}`
+      }
+      return this.generateNode(a)
+    }).join(', ')
+    
     return `${callee}(${args})`
   }
 
@@ -686,6 +686,9 @@ class PHPGenerator {
     if (node.computed) {
       return `${object}[${property}]`
     }
+    if (node.nullSafe) {
+      return `${object}?->${property}`
+    }
     return `${object}->${property}`
   }
 
@@ -695,15 +698,41 @@ class PHPGenerator {
     let op = node.operator
 
     const opMap = {
-      'et': '&&',
-      'ou': '||',
-      'concatener': '.'
+      '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': '??'
     }
-    op = opMap[op] || op
+    
+    op = opMap[op?.toLowerCase()] || op
 
     return `${left} ${op} ${right}`
   }
 
+  generateUnaryExpression(node) {
+    const argument = this.generateNode(node.argument)
+    const op = node.operator === 'non' || node.operator === 'not' ? '!' : node.operator
+    
+    if (node.prefix) {
+      return `${op}${argument}`
+    }
+    return `${argument}${op}`
+  }
+
+  generateUpdateExpression(node) {
+    const argument = this.generateNode(node.argument)
+    const op = node.operator
+    
+    if (node.prefix) {
+      return `${op}${argument}`
+    }
+    return `${argument}${op}`
+  }
+
   generateAssignmentExpression(node) {
     const left = this.generateNode(node.left)
     const right = this.generateNode(node.right)
@@ -711,18 +740,35 @@ class PHPGenerator {
     return `${left} ${op} ${right}`
   }
 
+  generateConditionalExpression(node) {
+    const test = this.generateNode(node.test)
+    const consequent = this.generateNode(node.consequent)
+    const alternate = this.generateNode(node.alternate)
+    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.key) {
+      if (!e) return 'null'
+      if (e.key !== undefined) {
         const key = this.generateNode(e.key)
         const value = this.generateNode(e.value || e)
         return `${key} => ${value}`
       }
+      if (e.spread) {
+        return '...' + this.generateNode(e.argument || e)
+      }
       return this.generateNode(e)
     })
     
     if (elements.length === 0) return '[]'
-    if (elements.length <= 3) {
+    if (elements.length <= 3 && !elements.some(e => e.includes('=>'))) {
       return `[${elements.join(', ')}]`
     }
     return `[\n${this.getIndent()}  ${elements.join(',\n' + this.getIndent() + '  ')}\n${this.getIndent()}]`
@@ -732,26 +778,75 @@ 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.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++
+    
+    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'
+    }
+    
+    this.indent--
+    result += this.getIndent() + '}'
+    return result
+  }
+
   generateIdentifier(node) {
-    const name = node.name || node
+    const name = node.name || node.id?.name || node
     if (typeof name !== 'string') return '$var'
     
     const translated = this.translate(name)
     
     if (translated.startsWith('$')) return translated
-    if (['true', 'false', 'null', 'self', 'parent', 'static'].includes(translated)) {
+    
+    const keywords = [
+      'true', 'false', 'null', 
+      'self', 'parent', 'static',
+      'this', '$this'
+    ]
+    if (keywords.includes(translated.toLowerCase())) {
+      if (translated.toLowerCase() === 'this') return '$this'
       return translated
     }
+    
     if (/^[A-Z]/.test(translated)) return translated
-    if (translated.includes('(')) return translated
+    
+    if (translated.includes('(') || translated.includes('::')) return translated
+    
+    const superglobals = ['_GET', '_POST', '_SERVER', '_SESSION', '_COOKIE', '_FILES', '_REQUEST', '_ENV', 'GLOBALS']
+    if (superglobals.includes(translated) || superglobals.includes(translated.toUpperCase())) {
+      return '$' + translated.toUpperCase()
+    }
     
     return '$' + translated
   }
 
   generateLiteral(node) {
-    if (node.raw) return node.raw
+    if (node.raw !== undefined) return node.raw
     if (typeof node.value === 'string') {
-      return `"${node.value.replace(/"/g, '\\"')}"`
+      const escaped = node.value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t')
+      return `"${escaped}"`
     }
     if (node.value === null) return 'null'
     if (node.value === true) return 'true'
@@ -761,12 +856,28 @@ class PHPGenerator {
 
   generateNewExpression(node) {
     const callee = typeof node.callee === 'string'
-      ? node.callee
+      ? this.translate(node.callee)
       : this.generateNode(node.callee)
     const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
     return `new ${callee}(${args})`
   }
 
+  generateInstanceOf(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    return `${left} instanceof ${right}`
+  }
+
+  generateBlockStatement(node) {
+    for (const stmt of node.body || []) {
+      this.generateNode(stmt)
+    }
+  }
+
+  write(text) {
+    this.output += text
+  }
+
   writeLine(text) {
     this.output += this.getIndent() + text + '\n'
   }
@@ -776,6 +887,6 @@ class PHPGenerator {
   }
 }
 
-module.exports = {
-  PHPGenerator
+module.exports = { 
+  PHPGenerator 
 }