ether-code 0.8.0 → 0.8.2

package/parsers/ether-parser-php.js

@@ -0,0 +1,2404 @@
+const { EtherParserBase, TokenType } = require('./ether-parser-base')
+
+class EtherParserPHP extends EtherParserBase {
+  constructor(options = {}) {
+    super(options)
+    this.initPHPTranslations()
+    this.loadI18n(['i18n-php.json'])
+  }
+
+  initPHPTranslations() {
+    this.phpTranslations = {
+      'variable': '$',
+      'constante': 'const',
+      'definir': 'define',
+      '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',
+      'etendre': 'extends',
+      'etend': 'extends',
+      'implementer': 'implements',
+      'implemente': 'implements',
+      'abstrait': 'abstract',
+      'abstraite': 'abstract',
+      'final': 'final',
+      'finale': 'final',
+      'public': 'public',
+      'publique': 'public',
+      'prive': 'private',
+      'privee': 'private',
+      'protege': 'protected',
+      'protegee': 'protected',
+      'statique': 'static',
+      'readonly': 'readonly',
+      'lecture seule': 'readonly',
+      'constructeur': '__construct',
+      'destructeur': '__destruct',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'rien': 'null',
+      'ceci': '$this',
+      'self': 'self',
+      'parent': 'parent',
+      'echo': 'echo',
+      'afficher': 'echo',
+      'imprimer': 'print',
+      'print': 'print',
+      'inclure': 'include',
+      'inclure une fois': 'include_once',
+      'require': 'require',
+      'requerir': 'require',
+      'require une fois': 'require_once',
+      'requerir une fois': 'require_once',
+      'utiliser': 'use',
+      'comme': 'as',
+      'namespace': 'namespace',
+      'espace de noms': 'namespace',
+      'global': 'global',
+      'instanceof': 'instanceof',
+      'instance de': 'instanceof',
+      'clone': 'clone',
+      'cloner': 'clone',
+      'rendement': 'yield',
+      'rendement de': 'yield from',
+      'fn': 'fn',
+      'match': 'match',
+      'enum': 'enum',
+      'enumeration': 'enum',
+      'addition': '+',
+      'soustraction': '-',
+      'multiplication': '*',
+      'division': '/',
+      'modulo': '%',
+      'puissance': '**',
+      'egal': '==',
+      'strictement egal': '===',
+      'different': '!=',
+      'strictement different': '!==',
+      'superieur': '>',
+      'inferieur': '<',
+      'superieur ou egal': '>=',
+      'inferieur ou egal': '<=',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'xor': 'xor',
+      'coalescence': '??',
+      'coalescence nulle': '??',
+      'fleche': '->',
+      'double fleche': '=>',
+      'double deux points': '::',
+      'resolution portee': '::',
+      'concatener': '.',
+      'concatenation': '.',
+      'chaine': 'string',
+      'entier': 'int',
+      'flottant': 'float',
+      'booleen': 'bool',
+      'tableau': 'array',
+      'objet': 'object',
+      'mixte': 'mixed',
+      'void': 'void',
+      'jamais': 'never',
+      'appelable': 'callable',
+      'iterable': 'iterable',
+      'longueur': 'strlen',
+      'sous chaine': 'substr',
+      'position': 'strpos',
+      'remplacer': 'str_replace',
+      'exploser': 'explode',
+      'imploser': 'implode',
+      'majuscules': 'strtoupper',
+      'minuscules': 'strtolower',
+      'rogner': 'trim',
+      'compter': 'count',
+      'trier': 'sort',
+      'inverser': 'array_reverse',
+      'fusionner': 'array_merge',
+      'filtrer': 'array_filter',
+      'transformer': 'array_map',
+      'reduire': 'array_reduce',
+      'cles': 'array_keys',
+      'valeurs': 'array_values',
+      'pousser': 'array_push',
+      'retirer': 'array_pop',
+      'rechercher': 'array_search',
+      'existe': 'array_key_exists',
+      'dans tableau': 'in_array',
+      'ouvrir fichier': 'fopen',
+      'fermer fichier': 'fclose',
+      'lire fichier': 'fread',
+      'ecrire fichier': 'fwrite',
+      'contenu fichier': 'file_get_contents',
+      'ecrire contenu': 'file_put_contents',
+      'fichier existe': 'file_exists',
+      'est fichier': 'is_file',
+      'est repertoire': 'is_dir',
+      'json encoder': 'json_encode',
+      'json decoder': 'json_decode',
+      'date': 'date',
+      'temps': 'time',
+      'maintenant': 'time',
+      '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',
+      'preparer': 'prepare',
+      'executer': 'execute',
+      'recuperer': 'fetch',
+      'recuperer tout': 'fetchAll',
+      'nombre lignes': 'rowCount',
+      'dernier id': 'lastInsertId',
+      'initialiser curl': 'curl_init',
+      'executer curl': 'curl_exec',
+      'fermer curl': 'curl_close',
+      'option curl': 'curl_setopt',
+      'envoyer mail': 'mail',
+      'afficher info': 'var_dump',
+      'imprimer r': 'print_r',
+      'exporter': 'var_export',
+      'vide': 'empty',
+      'defini': 'isset',
+      'supprimer': 'unset',
+      'sortie': 'exit',
+      'mourir': 'die',
+      'dormir': 'sleep'
+    }
+
+    this.phpTypes = {
+      'chaine': 'string',
+      'string': 'string',
+      'entier': 'int',
+      'int': 'int',
+      'integer': 'int',
+      'flottant': 'float',
+      'float': 'float',
+      'double': 'float',
+      'booleen': 'bool',
+      'bool': 'bool',
+      'boolean': 'bool',
+      'tableau': 'array',
+      'array': 'array',
+      'objet': 'object',
+      'object': 'object',
+      'mixte': 'mixed',
+      'mixed': 'mixed',
+      'void': 'void',
+      'nul': 'null',
+      'null': 'null',
+      'jamais': 'never',
+      'never': 'never',
+      'appelable': 'callable',
+      'callable': 'callable',
+      'iterable': 'iterable',
+      'ressource': 'resource',
+      'resource': 'resource',
+      'self': 'self',
+      'static': 'static',
+      'statique': 'static',
+      'parent': 'parent'
+    }
+
+    this.phpVisibility = ['public', 'publique', 'prive', 'privee', 'private', 'protege', 'protegee', 'protected']
+    this.phpModifiers = ['statique', 'static', 'final', 'finale', 'abstrait', 'abstraite', 'abstract', 'readonly', 'lecture seule']
+  }
+
+  translatePHP(word) {
+    if (!word) return word
+    const lower = this.normalizeAccents(String(word))
+    return this.phpTranslations[lower] || word
+  }
+
+  translateType(word) {
+    if (!word) return word
+    const lower = this.normalizeAccents(String(word))
+    return this.phpTypes[lower] || word
+  }
+
+  parse(source, lang = 'php') {
+    this.tokenize(source)
+    return this.parseProgram(lang)
+  }
+
+  parseProgram(lang) {
+    const program = {
+      type: 'Program',
+      lang: lang,
+      body: [],
+      phpTag: true
+    }
+
+    this.skipNewlines()
+
+    while (!this.isAtEnd()) {
+      const statement = this.parseStatement(lang)
+      if (statement) {
+        program.body.push(statement)
+      }
+      this.skipNewlines()
+    }
+
+    return program
+  }
+
+  parseStatement(lang) {
+    this.skipNewlines()
+    const token = this.current()
+
+    if (!token || token.type === TokenType.EOF) return null
+
+    const value = token.value != null ? this.normalizeAccents(String(token.value).toLowerCase()) : ''
+
+    if (this.isNamespace(value)) {
+      return this.parseNamespace(lang)
+    }
+
+    if (this.isUse(value)) {
+      return this.parseUseStatement(lang)
+    }
+
+    if (this.isClassDeclaration(value)) {
+      return this.parseClassDeclaration(lang)
+    }
+
+    if (this.isInterfaceDeclaration(value)) {
+      return this.parseInterfaceDeclaration(lang)
+    }
+
+    if (this.isTraitDeclaration(value)) {
+      return this.parseTraitDeclaration(lang)
+    }
+
+    if (this.isEnumDeclaration(value)) {
+      return this.parseEnumDeclaration(lang)
+    }
+
+    if (this.isFunctionDeclaration(value)) {
+      return this.parseFunctionDeclaration(lang)
+    }
+
+    if (this.isVariableDeclaration(value)) {
+      return this.parseVariableDeclaration(lang)
+    }
+
+    if (this.isConditional(value)) {
+      return this.parseConditional(lang)
+    }
+
+    if (this.isLoop(value)) {
+      return this.parseLoop(lang)
+    }
+
+    if (this.isSwitch(value)) {
+      return this.parseSwitch(lang)
+    }
+
+    if (this.isTry(value)) {
+      return this.parseTryStatement(lang)
+    }
+
+    if (this.isThrow(value)) {
+      return this.parseThrowStatement(lang)
+    }
+
+    if (this.isReturn(value)) {
+      return this.parseReturn(lang)
+    }
+
+    if (this.isEcho(value)) {
+      return this.parseEcho(lang)
+    }
+
+    if (this.isInclude(value)) {
+      return this.parseInclude(lang)
+    }
+
+    if (this.isGlobal(value)) {
+      return this.parseGlobalStatement(lang)
+    }
+
+    if (this.isMatch(value)) {
+      return this.parseMatchExpression(lang)
+    }
+
+    if (value === 'sortir' || value === 'break') {
+      this.advance()
+      return { type: 'BreakStatement' }
+    }
+
+    if (value === 'continuer' || value === 'continue') {
+      this.advance()
+      return { type: 'ContinueStatement' }
+    }
+
+    const expr = this.parseExpression(lang)
+    if (expr) {
+      return {
+        type: 'ExpressionStatement',
+        expression: expr
+      }
+    }
+    return null
+  }
+
+  isNamespace(value) {
+    return ['namespace', 'espace de noms'].includes(value)
+  }
+
+  isUse(value) {
+    return ['utiliser', 'use'].includes(value)
+  }
+
+  isClassDeclaration(value) {
+    const keywords = ['classe', 'class', 'abstrait', 'abstraite', 'abstract', 'final', 'finale', 'readonly']
+    if (keywords.includes(value)) {
+      if (['abstrait', 'abstraite', 'abstract', 'final', 'finale', 'readonly'].includes(value)) {
+        const next = this.peek(1)
+        if (next) {
+          const nextVal = this.normalizeAccents(String(next.value).toLowerCase())
+          return ['classe', 'class'].includes(nextVal)
+        }
+      }
+      return true
+    }
+    return false
+  }
+
+  isInterfaceDeclaration(value) {
+    return ['interface'].includes(value)
+  }
+
+  isTraitDeclaration(value) {
+    return ['trait'].includes(value)
+  }
+
+  isEnumDeclaration(value) {
+    return ['enum', 'enumeration'].includes(value)
+  }
+
+  isFunctionDeclaration(value) {
+    const keywords = ['fonction', 'function', 'fn', 'methode', 'procedure']
+    return keywords.includes(value)
+  }
+
+  isVariableDeclaration(value) {
+    const keywords = ['variable', 'constante', 'const', 'definir', 'define', 'statique', 'static', 'global']
+    return keywords.includes(value)
+  }
+
+  isConditional(value) {
+    return ['si', 'if'].includes(value)
+  }
+
+  isLoop(value) {
+    const keywords = ['pour', 'for', 'foreach', 'pour chaque', 'while', 'tant que', 'faire', 'do']
+    if (keywords.includes(value)) return true
+    if (value === 'tant') {
+      const next = this.peek(1)
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'que') {
+        return true
+      }
+    }
+    if (value === 'pour') {
+      const next = this.peek(1)
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'chaque') {
+        return true
+      }
+    }
+    return false
+  }
+
+  isSwitch(value) {
+    return ['selon', 'switch'].includes(value)
+  }
+
+  isTry(value) {
+    return ['essayer', 'try'].includes(value)
+  }
+
+  isThrow(value) {
+    return ['lancer', 'throw'].includes(value)
+  }
+
+  isReturn(value) {
+    return ['retourner', 'return', 'renvoyer'].includes(value)
+  }
+
+  isEcho(value) {
+    return ['echo', 'afficher', 'imprimer', 'print'].includes(value)
+  }
+
+  isInclude(value) {
+    return ['inclure', 'include', 'require', 'requerir', 'inclure une fois', 'include_once', 'require une fois', 'require_once', 'requerir une fois'].includes(value)
+  }
+
+  isGlobal(value) {
+    return value === 'global'
+  }
+
+  isMatch(value) {
+    return value === 'match'
+  }
+
+  parseNamespace(lang) {
+    this.advance()
+    const name = this.parseNamespacePath(lang)
+    this.skipNewlines()
+    
+    let body = null
+    if (this.check(TokenType.LBRACE)) {
+      body = this.parseBlock(lang)
+    }
+
+    return {
+      type: 'NamespaceDeclaration',
+      name: name,
+      body: body
+    }
+  }
+
+  parseNamespacePath(lang) {
+    const parts = []
+    
+    while (this.current() && this.current().type === TokenType.IDENTIFIER) {
+      parts.push(this.advance().value)
+      if (this.match(TokenType.BACKSLASH) || this.matchValue('\\')) {
+        continue
+      }
+      break
+    }
+
+    return parts.join('\\')
+  }
+
+  parseUseStatement(lang) {
+    this.advance()
+    
+    let useType = null
+    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (val === 'fonction' || val === 'function') {
+      useType = 'function'
+      this.advance()
+    } else if (val === 'constante' || val === 'const') {
+      useType = 'const'
+      this.advance()
+    }
+
+    const imports = []
+    
+    do {
+      const path = this.parseNamespacePath(lang)
+      let alias = null
+      
+      const asVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (asVal === 'comme' || asVal === 'as') {
+        this.advance()
+        alias = this.advance().value
+      }
+
+      imports.push({
+        path: path,
+        alias: alias
+      })
+    } while (this.match(TokenType.COMMA))
+
+    return {
+      type: 'UseStatement',
+      useType: useType,
+      imports: imports
+    }
+  }
+
+  parseClassDeclaration(lang) {
+    const modifiers = []
+
+    while (true) {
+      const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (['abstrait', 'abstraite', 'abstract'].includes(val)) {
+        modifiers.push('abstract')
+        this.advance()
+      } else if (['final', 'finale'].includes(val)) {
+        modifiers.push('final')
+        this.advance()
+      } else if (val === 'readonly') {
+        modifiers.push('readonly')
+        this.advance()
+      } else {
+        break
+      }
+    }
+
+    this.advance()
+
+    const nameToken = this.current()
+    const name = nameToken ? nameToken.value : 'AnonymousClass'
+    if (nameToken) this.advance()
+
+    let superClass = null
+    const extendsVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (['etendre', 'etend', 'extends'].includes(extendsVal)) {
+      this.advance()
+      superClass = this.parseNamespacePath(lang)
+    }
+
+    const interfaces = []
+    const implementsVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (['implementer', 'implemente', 'implements'].includes(implementsVal)) {
+      this.advance()
+      do {
+        interfaces.push(this.parseNamespacePath(lang))
+      } while (this.match(TokenType.COMMA))
+    }
+
+    this.skipNewlines()
+    const body = this.parseClassBody(lang)
+
+    return {
+      type: 'ClassDeclaration',
+      name: name,
+      modifiers: modifiers,
+      superClass: superClass,
+      interfaces: interfaces,
+      body: body
+    }
+  }
+
+  parseClassBody(lang) {
+    const members = []
+    
+    this.match(TokenType.LBRACE)
+    this.skipNewlines()
+    this.match(TokenType.INDENT)
+
+    while (!this.isAtEnd()) {
+      this.skipNewlines()
+      const current = this.current()
+
+      if (!current) break
+      if (current.type === TokenType.RBRACE || current.type === TokenType.DEDENT) {
+        this.advance()
+        break
+      }
+
+      const member = this.parseClassMember(lang)
+      if (member) {
+        members.push(member)
+      }
+      this.skipNewlines()
+    }
+
+    this.match(TokenType.RBRACE)
+
+    return members
+  }
+
+  parseClassMember(lang) {
+    const modifiers = []
+    let visibility = null
+    let isStatic = false
+    let isReadonly = false
+    let isAbstract = false
+    let isFinal = false
+
+    while (true) {
+      const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      
+      if (['public', 'publique'].includes(val)) {
+        visibility = 'public'
+        this.advance()
+      } else if (['prive', 'privee', 'private'].includes(val)) {
+        visibility = 'private'
+        this.advance()
+      } else if (['protege', 'protegee', 'protected'].includes(val)) {
+        visibility = 'protected'
+        this.advance()
+      } else if (['statique', 'static'].includes(val)) {
+        isStatic = true
+        this.advance()
+      } else if (val === 'readonly' || val === 'lecture seule') {
+        isReadonly = true
+        this.advance()
+      } else if (['abstrait', 'abstraite', 'abstract'].includes(val)) {
+        isAbstract = true
+        this.advance()
+      } else if (['final', 'finale'].includes(val)) {
+        isFinal = true
+        this.advance()
+      } else {
+        break
+      }
+    }
+
+    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+
+    if (['fonction', 'function', 'methode'].includes(val)) {
+      return this.parseMethodDeclaration(lang, visibility, isStatic, isAbstract, isFinal)
+    }
+
+    if (val === 'constante' || val === 'const') {
+      return this.parseClassConstant(lang, visibility)
+    }
+
+    if (val === 'utiliser' || val === 'use') {
+      return this.parseTraitUse(lang)
+    }
+
+    return this.parsePropertyDeclaration(lang, visibility, isStatic, isReadonly)
+  }
+
+  parseMethodDeclaration(lang, visibility, isStatic, isAbstract, isFinal) {
+    this.advance()
+
+    let isConstructor = false
+    let isDestructor = false
+    const nameToken = this.current()
+    let name = nameToken ? nameToken.value : 'anonyme'
+    
+    const nameLower = this.normalizeAccents(name.toLowerCase())
+    if (nameLower === 'constructeur' || nameLower === '__construct') {
+      name = '__construct'
+      isConstructor = true
+    } else if (nameLower === 'destructeur' || nameLower === '__destruct') {
+      name = '__destruct'
+      isDestructor = true
+    }
+    
+    if (nameToken) this.advance()
+
+    const params = this.parseParameters(lang)
+    
+    let returnType = null
+    if (this.match(TokenType.COLON)) {
+      let nullable = false
+      if (this.match(TokenType.QUESTION)) {
+        nullable = true
+      }
+      returnType = this.parseTypeHint(lang)
+      if (returnType && nullable) {
+        returnType.nullable = true
+      }
+    }
+
+    this.skipNewlines()
+    
+    let body = null
+    if (!isAbstract) {
+      body = this.parseBlock(lang)
+    }
+
+    return {
+      type: 'MethodDeclaration',
+      name: name,
+      visibility: visibility || 'public',
+      static: isStatic,
+      abstract: isAbstract,
+      final: isFinal,
+      constructor: isConstructor,
+      destructor: isDestructor,
+      params: params,
+      returnType: returnType,
+      body: body
+    }
+  }
+
+  parsePropertyDeclaration(lang, visibility, isStatic, isReadonly) {
+    let typeHint = null
+
+    const current = this.current()
+    if (current && current.type === TokenType.IDENTIFIER) {
+      const typeLower = this.normalizeAccents(String(current.value).toLowerCase())
+      if (this.phpTypes[typeLower]) {
+        typeHint = this.parseTypeHint(lang)
+      }
+    }
+
+    const nameToken = this.current()
+    let name = nameToken ? nameToken.value : 'property'
+    
+    if (name.startsWith('$')) {
+      name = name.substring(1)
+    }
+    
+    if (nameToken) this.advance()
+
+    let defaultValue = null
+    if (this.match(TokenType.EQUALS)) {
+      defaultValue = this.parseExpression(lang)
+    }
+
+    return {
+      type: 'PropertyDeclaration',
+      name: name,
+      visibility: visibility || 'public',
+      static: isStatic,
+      readonly: isReadonly,
+      typeHint: typeHint,
+      default: defaultValue
+    }
+  }
+
+  parseClassConstant(lang, visibility) {
+    this.advance()
+
+    const nameToken = this.current()
+    const name = nameToken ? nameToken.value : 'CONSTANT'
+    if (nameToken) this.advance()
+
+    this.match(TokenType.EQUALS)
+    const value = this.parseExpression(lang)
+
+    return {
+      type: 'ClassConstant',
+      name: name,
+      visibility: visibility || 'public',
+      value: value
+    }
+  }
+
+  parseTraitUse(lang) {
+    this.advance()
+    const traits = []
+
+    do {
+      traits.push(this.parseNamespacePath(lang))
+    } while (this.match(TokenType.COMMA))
+
+    let adaptations = []
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.isAtEnd() && !this.check(TokenType.RBRACE)) {
+        this.skipNewlines()
+        adaptations.push(this.parseTraitAdaptation(lang))
+        this.match(TokenType.SEMICOLON)
+        this.skipNewlines()
+      }
+      this.match(TokenType.RBRACE)
+    }
+
+    return {
+      type: 'TraitUse',
+      traits: traits,
+      adaptations: adaptations
+    }
+  }
+
+  parseTraitAdaptation(lang) {
+    const first = this.parseNamespacePath(lang)
+    
+    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    
+    if (val === 'insteadof' || val === 'au lieu de') {
+      this.advance()
+      const excluded = []
+      do {
+        excluded.push(this.parseNamespacePath(lang))
+      } while (this.match(TokenType.COMMA))
+      
+      return {
+        type: 'TraitPrecedence',
+        method: first,
+        insteadof: excluded
+      }
+    }
+
+    if (val === 'comme' || val === 'as') {
+      this.advance()
+      
+      let newVisibility = null
+      let newName = null
+      
+      const nextVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (this.phpVisibility.includes(nextVal)) {
+        newVisibility = this.translatePHP(nextVal)
+        this.advance()
+      }
+      
+      if (this.current() && this.current().type === TokenType.IDENTIFIER) {
+        newName = this.advance().value
+      }
+
+      return {
+        type: 'TraitAlias',
+        method: first,
+        newVisibility: newVisibility,
+        newName: newName
+      }
+    }
+
+    return { type: 'TraitAdaptation', value: first }
+  }
+
+  parseInterfaceDeclaration(lang) {
+    this.advance()
+
+    const nameToken = this.current()
+    const name = nameToken ? nameToken.value : 'AnonymousInterface'
+    if (nameToken) this.advance()
+
+    const extended = []
+    const extendsVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (['etendre', 'etend', 'extends'].includes(extendsVal)) {
+      this.advance()
+      do {
+        extended.push(this.parseNamespacePath(lang))
+      } while (this.match(TokenType.COMMA))
+    }
+
+    this.skipNewlines()
+    const body = this.parseClassBody(lang)
+
+    return {
+      type: 'InterfaceDeclaration',
+      name: name,
+      extends: extended,
+      body: body
+    }
+  }
+
+  parseTraitDeclaration(lang) {
+    this.advance()
+
+    const nameToken = this.current()
+    const name = nameToken ? nameToken.value : 'AnonymousTrait'
+    if (nameToken) this.advance()
+
+    this.skipNewlines()
+    const body = this.parseClassBody(lang)
+
+    return {
+      type: 'TraitDeclaration',
+      name: name,
+      body: body
+    }
+  }
+
+  parseEnumDeclaration(lang) {
+    this.advance()
+
+    const nameToken = this.current()
+    const name = nameToken ? nameToken.value : 'AnonymousEnum'
+    if (nameToken) this.advance()
+
+    let backingType = null
+    if (this.match(TokenType.COLON)) {
+      backingType = this.parseTypeHint(lang)
+    }
+
+    const interfaces = []
+    const implementsVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (['implementer', 'implemente', 'implements'].includes(implementsVal)) {
+      this.advance()
+      do {
+        interfaces.push(this.parseNamespacePath(lang))
+      } while (this.match(TokenType.COMMA))
+    }
+
+    this.skipNewlines()
+    const cases = this.parseEnumBody(lang)
+
+    return {
+      type: 'EnumDeclaration',
+      name: name,
+      backingType: backingType,
+      interfaces: interfaces,
+      cases: cases
+    }
+  }
+
+  parseEnumBody(lang) {
+    const members = []
+    
+    this.match(TokenType.LBRACE)
+    this.skipNewlines()
+    this.match(TokenType.INDENT)
+
+    while (!this.isAtEnd()) {
+      this.skipNewlines()
+      const current = this.current()
+
+      if (!current) break
+      if (current.type === TokenType.RBRACE || current.type === TokenType.DEDENT) {
+        this.advance()
+        break
+      }
+
+      const val = this.normalizeAccents(String(current.value).toLowerCase())
+      
+      if (val === 'cas' || val === 'case') {
+        this.advance()
+        const caseName = this.advance().value
+        let caseValue = null
+        if (this.match(TokenType.EQUALS)) {
+          caseValue = this.parseExpression(lang)
+        }
+        members.push({
+          type: 'EnumCase',
+          name: caseName,
+          value: caseValue
+        })
+      } else {
+        const member = this.parseClassMember(lang)
+        if (member) {
+          members.push(member)
+        }
+      }
+      this.skipNewlines()
+    }
+
+    this.match(TokenType.RBRACE)
+    return members
+  }
+
+  parseFunctionDeclaration(lang) {
+    const isArrow = this.current() && this.normalizeAccents(String(this.current().value).toLowerCase()) === 'fn'
+    this.advance()
+
+    let isReference = false
+    if (this.match(TokenType.AMPERSAND)) {
+      isReference = true
+    }
+
+    const nameToken = this.current()
+    const name = nameToken && nameToken.type === TokenType.IDENTIFIER ? nameToken.value : null
+    if (name) this.advance()
+
+    const params = this.parseParameters(lang)
+    
+    let uses = []
+    const useVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (useVal === 'utiliser' || useVal === 'use') {
+      this.advance()
+      uses = this.parseClosureUse(lang)
+    }
+
+    let returnType = null
+    if (this.match(TokenType.COLON)) {
+      let nullable = false
+      if (this.match(TokenType.QUESTION)) {
+        nullable = true
+      }
+      returnType = this.parseTypeHint(lang)
+      if (returnType && nullable) {
+        returnType.nullable = true
+      }
+    }
+
+    this.skipNewlines()
+
+    let body
+    if (isArrow && this.match(TokenType.ARROW) || this.match(TokenType.DOUBLE_ARROW)) {
+      body = {
+        type: 'ReturnStatement',
+        argument: this.parseExpression(lang)
+      }
+      return {
+        type: 'ArrowFunctionDeclaration',
+        name: name,
+        params: params,
+        returnType: returnType,
+        body: body,
+        reference: isReference
+      }
+    }
+
+    body = this.parseBlock(lang)
+
+    return {
+      type: 'FunctionDeclaration',
+      name: name,
+      params: params,
+      uses: uses,
+      returnType: returnType,
+      body: body,
+      reference: isReference
+    }
+  }
+
+  parseClosureUse(lang) {
+    const uses = []
+    this.match(TokenType.LPAREN)
+
+    while (!this.isAtEnd() && !this.check(TokenType.RPAREN)) {
+      let byRef = false
+      if (this.match(TokenType.AMPERSAND)) {
+        byRef = true
+      }
+      
+      const varToken = this.current()
+      let varName = varToken ? varToken.value : ''
+      if (varName.startsWith('$')) {
+        varName = varName.substring(1)
+      }
+      this.advance()
+
+      uses.push({
+        name: varName,
+        byReference: byRef
+      })
+
+      this.match(TokenType.COMMA)
+    }
+
+    this.match(TokenType.RPAREN)
+    return uses
+  }
+
+  parseParameters(lang) {
+    const params = []
+    this.match(TokenType.LPAREN)
+
+    while (!this.isAtEnd() && !this.check(TokenType.RPAREN)) {
+      this.skipNewlines()
+      if (this.check(TokenType.RPAREN)) break
+
+      const param = this.parseParameterPHP(lang)
+      if (param) {
+        params.push(param)
+      }
+      this.match(TokenType.COMMA)
+      this.skipNewlines()
+    }
+
+    this.match(TokenType.RPAREN)
+    return params
+  }
+
+  parseParameterPHP(lang) {
+    let visibility = null
+    let readonly = false
+    let typeHint = null
+    let variadic = false
+    let byReference = false
+    let defaultValue = null
+
+    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (this.phpVisibility.includes(val)) {
+      visibility = this.translatePHP(val)
+      this.advance()
+    }
+
+    const readonlyVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (readonlyVal === 'readonly' || readonlyVal === 'lecture seule') {
+      readonly = true
+      this.advance()
+    }
+
+    const currentType = this.current()
+    if (currentType && currentType.type === TokenType.IDENTIFIER) {
+      const typeLower = this.normalizeAccents(String(currentType.value).toLowerCase())
+      if (this.phpTypes[typeLower] || typeLower[0] === typeLower[0].toUpperCase()) {
+        if (!this.peek(1) || this.peek(1).type !== TokenType.EQUALS) {
+          typeHint = this.parseTypeHint(lang)
+        }
+      }
+    }
+
+    if (this.match(TokenType.SPREAD) || this.matchValue('...')) {
+      variadic = true
+    }
+
+    if (this.match(TokenType.AMPERSAND)) {
+      byReference = true
+    }
+
+    const nameToken = this.current()
+    if (!nameToken) return null
+    
+    let name = nameToken.value
+    if (name.startsWith('$')) {
+      name = name.substring(1)
+    }
+    this.advance()
+
+    if (this.match(TokenType.EQUALS)) {
+      defaultValue = this.parseExpression(lang)
+    }
+
+    return {
+      type: 'Parameter',
+      name: name,
+      typeHint: typeHint,
+      visibility: visibility,
+      readonly: readonly,
+      variadic: variadic,
+      byReference: byReference,
+      default: defaultValue
+    }
+  }
+
+  parseTypeHint(lang) {
+    let nullable = false
+    if (this.match(TokenType.QUESTION)) {
+      nullable = true
+    }
+
+    const types = []
+    
+    do {
+      const typeToken = this.current()
+      if (!typeToken || typeToken.type !== TokenType.IDENTIFIER) break
+      
+      const typeName = this.translateType(typeToken.value)
+      this.advance()
+      types.push(typeName)
+    } while (this.match(TokenType.PIPE))
+
+    if (types.length === 0) return null
+
+    return {
+      type: 'TypeHint',
+      types: types,
+      nullable: nullable,
+      union: types.length > 1
+    }
+  }
+
+  parseVariableDeclaration(lang) {
+    const kindToken = this.advance()
+    const kindLower = this.normalizeAccents(String(kindToken.value).toLowerCase())
+
+    if (kindLower === 'constante' || kindLower === 'const') {
+      const nameToken = this.current()
+      const name = nameToken ? nameToken.value : 'CONSTANT'
+      if (nameToken) this.advance()
+
+      this.match(TokenType.EQUALS)
+      const value = this.parseExpression(lang)
+
+      return {
+        type: 'ConstantDeclaration',
+        name: name,
+        value: value
+      }
+    }
+
+    if (kindLower === 'definir' || kindLower === 'define') {
+      this.match(TokenType.LPAREN)
+      const nameExpr = this.parseExpression(lang)
+      this.match(TokenType.COMMA)
+      const value = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+
+      return {
+        type: 'DefineDeclaration',
+        name: nameExpr,
+        value: value
+      }
+    }
+
+    let typeHint = null
+    const currentType = this.current()
+    if (currentType && currentType.type === TokenType.IDENTIFIER) {
+      const typeLower = this.normalizeAccents(String(currentType.value).toLowerCase())
+      if (this.phpTypes[typeLower]) {
+        typeHint = this.parseTypeHint(lang)
+      }
+    }
+
+    const nameToken = this.current()
+    let name = nameToken ? nameToken.value : 'variable'
+    if (name.startsWith('$')) {
+      name = name.substring(1)
+    }
+    if (nameToken) this.advance()
+
+    let initializer = null
+    if (this.match(TokenType.EQUALS)) {
+      initializer = this.parseExpression(lang)
+    }
+
+    return {
+      type: 'VariableDeclaration',
+      kind: kindLower === 'statique' || kindLower === 'static' ? 'static' : 'var',
+      name: name,
+      typeHint: typeHint,
+      init: initializer
+    }
+  }
+
+  parseConditional(lang) {
+    this.advance()
+
+    let condition
+    if (this.match(TokenType.LPAREN)) {
+      condition = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+    } else {
+      condition = this.parseExpression(lang)
+    }
+
+    this.skipNewlines()
+    const consequent = this.parseBlock(lang)
+
+    let alternate = null
+    this.skipNewlines()
+    
+    const elseVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (elseVal === 'sinon si' || elseVal === 'elseif') {
+      this.advance()
+      alternate = this.parseConditional(lang)
+      alternate.type = 'ElseIfStatement'
+    } else if (elseVal === 'sinon' || elseVal === 'else') {
+      this.advance()
+      
+      const nextVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (nextVal === 'si' || nextVal === 'if') {
+        alternate = this.parseConditional(lang)
+        alternate.type = 'ElseIfStatement'
+      } else {
+        this.skipNewlines()
+        alternate = this.parseBlock(lang)
+      }
+    }
+
+    return {
+      type: 'IfStatement',
+      condition: condition,
+      consequent: consequent,
+      alternate: alternate
+    }
+  }
+
+  parseLoop(lang) {
+    const token = this.current()
+    const value = this.normalizeAccents(String(token.value).toLowerCase())
+
+    if (value === 'pour') {
+      const next = this.peek(1)
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'chaque') {
+        this.advance()
+        this.advance()
+        return this.parseForeach(lang)
+      }
+      return this.parseFor(lang)
+    }
+
+    if (value === 'foreach' || value === 'pour chaque') {
+      this.advance()
+      if (value === 'pour chaque') this.advance()
+      return this.parseForeach(lang)
+    }
+
+    if (value === 'while' || value === 'tant') {
+      this.advance()
+      if (value === 'tant') {
+        this.matchValue('que')
+      }
+      return this.parseWhile(lang)
+    }
+
+    if (value === 'faire' || value === 'do') {
+      return this.parseDoWhile(lang)
+    }
+
+    this.advance()
+    return this.parseFor(lang)
+  }
+
+  parseFor(lang) {
+    this.advance()
+
+    let init = null
+    let test = null
+    let update = null
+
+    if (this.match(TokenType.LPAREN)) {
+      if (!this.check(TokenType.SEMICOLON)) {
+        init = this.parseExpression(lang)
+      }
+      this.match(TokenType.SEMICOLON)
+      
+      if (!this.check(TokenType.SEMICOLON)) {
+        test = this.parseExpression(lang)
+      }
+      this.match(TokenType.SEMICOLON)
+      
+      if (!this.check(TokenType.RPAREN)) {
+        update = this.parseExpression(lang)
+      }
+      this.match(TokenType.RPAREN)
+    }
+
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+
+    return {
+      type: 'ForStatement',
+      init: init,
+      test: test,
+      update: update,
+      body: body
+    }
+  }
+
+  parseForeach(lang) {
+    let array = null
+    let key = null
+    let value = null
+    let byRef = false
+
+    if (this.match(TokenType.LPAREN)) {
+      array = this.parseExpression(lang)
+      
+      const asVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (asVal === 'comme' || asVal === 'as') {
+        this.advance()
+      }
+
+      if (this.match(TokenType.AMPERSAND)) {
+        byRef = true
+      }
+
+      const firstVar = this.current()
+      let firstName = firstVar ? firstVar.value : 'item'
+      if (firstName.startsWith('$')) firstName = firstName.substring(1)
+      this.advance()
+
+      if (this.match(TokenType.DOUBLE_ARROW) || this.matchValue('=>')) {
+        key = firstName
+        
+        if (this.match(TokenType.AMPERSAND)) {
+          byRef = true
+        }
+        
+        const valueVar = this.current()
+        value = valueVar ? valueVar.value : 'value'
+        if (value.startsWith('$')) value = value.substring(1)
+        this.advance()
+      } else {
+        value = firstName
+      }
+
+      this.match(TokenType.RPAREN)
+    }
+
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+
+    return {
+      type: 'ForeachStatement',
+      array: array,
+      key: key,
+      value: value,
+      byReference: byRef,
+      body: body
+    }
+  }
+
+  parseWhile(lang) {
+    let condition
+    if (this.match(TokenType.LPAREN)) {
+      condition = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+    } else {
+      condition = this.parseExpression(lang)
+    }
+
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+
+    return {
+      type: 'WhileStatement',
+      condition: condition,
+      body: body
+    }
+  }
+
+  parseDoWhile(lang) {
+    this.advance()
+
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+
+    this.skipNewlines()
+    const whileVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (whileVal === 'while' || whileVal === 'tant') {
+      this.advance()
+      if (whileVal === 'tant') {
+        this.matchValue('que')
+      }
+    }
+
+    let condition
+    if (this.match(TokenType.LPAREN)) {
+      condition = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+    } else {
+      condition = this.parseExpression(lang)
+    }
+
+    return {
+      type: 'DoWhileStatement',
+      body: body,
+      condition: condition
+    }
+  }
+
+  parseSwitch(lang) {
+    this.advance()
+
+    let discriminant
+    if (this.match(TokenType.LPAREN)) {
+      discriminant = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+    } else {
+      discriminant = this.parseExpression(lang)
+    }
+
+    this.skipNewlines()
+    const cases = this.parseSwitchBody(lang)
+
+    return {
+      type: 'SwitchStatement',
+      discriminant: discriminant,
+      cases: cases
+    }
+  }
+
+  parseSwitchBody(lang) {
+    const cases = []
+    
+    this.match(TokenType.LBRACE)
+    this.skipNewlines()
+    this.match(TokenType.INDENT)
+
+    while (!this.isAtEnd()) {
+      this.skipNewlines()
+      const current = this.current()
+
+      if (!current) break
+      if (current.type === TokenType.RBRACE || current.type === TokenType.DEDENT) {
+        this.advance()
+        break
+      }
+
+      const val = this.normalizeAccents(String(current.value).toLowerCase())
+
+      if (val === 'cas' || val === 'case') {
+        this.advance()
+        const test = this.parseExpression(lang)
+        this.match(TokenType.COLON)
+        this.skipNewlines()
+        
+        const consequent = []
+        while (!this.isAtEnd()) {
+          const nextVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+          if (['cas', 'case', 'defaut', 'default'].includes(nextVal) || 
+              this.current().type === TokenType.RBRACE ||
+              this.current().type === TokenType.DEDENT) {
+            break
+          }
+          const stmt = this.parseStatement(lang)
+          if (stmt) consequent.push(stmt)
+          this.skipNewlines()
+        }
+
+        cases.push({
+          type: 'SwitchCase',
+          test: test,
+          consequent: consequent
+        })
+      } else if (val === 'defaut' || val === 'default') {
+        this.advance()
+        this.match(TokenType.COLON)
+        this.skipNewlines()
+        
+        const consequent = []
+        while (!this.isAtEnd()) {
+          if (this.current().type === TokenType.RBRACE || this.current().type === TokenType.DEDENT) {
+            break
+          }
+          const stmt = this.parseStatement(lang)
+          if (stmt) consequent.push(stmt)
+          this.skipNewlines()
+        }
+
+        cases.push({
+          type: 'SwitchCase',
+          test: null,
+          consequent: consequent
+        })
+      } else {
+        break
+      }
+    }
+
+    this.match(TokenType.RBRACE)
+    return cases
+  }
+
+  parseMatchExpression(lang) {
+    this.advance()
+
+    let subject
+    if (this.match(TokenType.LPAREN)) {
+      subject = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+    } else {
+      subject = this.parseExpression(lang)
+    }
+
+    this.skipNewlines()
+    const arms = this.parseMatchArms(lang)
+
+    return {
+      type: 'MatchExpression',
+      subject: subject,
+      arms: arms
+    }
+  }
+
+  parseMatchArms(lang) {
+    const arms = []
+    
+    this.match(TokenType.LBRACE)
+    this.skipNewlines()
+
+    while (!this.isAtEnd() && !this.check(TokenType.RBRACE)) {
+      this.skipNewlines()
+      
+      const conditions = []
+      let isDefault = false
+      
+      const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (val === 'defaut' || val === 'default') {
+        isDefault = true
+        this.advance()
+      } else {
+        do {
+          conditions.push(this.parseExpression(lang))
+        } while (this.match(TokenType.COMMA))
+      }
+
+      this.match(TokenType.DOUBLE_ARROW) || this.matchValue('=>')
+      const body = this.parseExpression(lang)
+
+      arms.push({
+        type: 'MatchArm',
+        conditions: isDefault ? null : conditions,
+        default: isDefault,
+        body: body
+      })
+
+      this.match(TokenType.COMMA)
+      this.skipNewlines()
+    }
+
+    this.match(TokenType.RBRACE)
+    return arms
+  }
+
+  parseTryStatement(lang) {
+    this.advance()
+
+    this.skipNewlines()
+    const tryBlock = this.parseBlock(lang)
+
+    const catches = []
+    this.skipNewlines()
+
+    while (true) {
+      const catchVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (catchVal !== 'attraper' && catchVal !== 'catch') break
+
+      this.advance()
+
+      let types = []
+      let param = null
+
+      if (this.match(TokenType.LPAREN)) {
+        do {
+          const typeToken = this.current()
+          if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
+            const typeName = typeToken.value
+            if (typeName.startsWith('$')) {
+              param = typeName.substring(1)
+            } else {
+              types.push(typeName)
+              this.advance()
+            }
+          }
+        } while (this.match(TokenType.PIPE))
+
+        if (!param) {
+          const paramToken = this.current()
+          if (paramToken && paramToken.type === TokenType.IDENTIFIER) {
+            param = paramToken.value
+            if (param.startsWith('$')) param = param.substring(1)
+            this.advance()
+          }
+        }
+        this.match(TokenType.RPAREN)
+      }
+
+      this.skipNewlines()
+      const catchBlock = this.parseBlock(lang)
+
+      catches.push({
+        type: 'CatchClause',
+        types: types,
+        param: param,
+        body: catchBlock
+      })
+
+      this.skipNewlines()
+    }
+
+    let finallyBlock = null
+    const finallyVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (finallyVal === 'finalement' || finallyVal === 'finally') {
+      this.advance()
+      this.skipNewlines()
+      finallyBlock = this.parseBlock(lang)
+    }
+
+    return {
+      type: 'TryStatement',
+      block: tryBlock,
+      catches: catches,
+      finally: finallyBlock
+    }
+  }
+
+  parseThrowStatement(lang) {
+    this.advance()
+    const argument = this.parseExpression(lang)
+
+    return {
+      type: 'ThrowStatement',
+      argument: argument
+    }
+  }
+
+  parseReturn(lang) {
+    this.advance()
+    
+    let argument = null
+    if (!this.isAtEnd() && 
+        !this.check(TokenType.NEWLINE) && 
+        !this.check(TokenType.SEMICOLON) &&
+        !this.check(TokenType.DEDENT)) {
+      argument = this.parseExpression(lang)
+    }
+
+    return {
+      type: 'ReturnStatement',
+      argument: argument
+    }
+  }
+
+  parseEcho(lang) {
+    const token = this.advance()
+    const isPrint = this.normalizeAccents(String(token.value).toLowerCase()) === 'print' || 
+                    this.normalizeAccents(String(token.value).toLowerCase()) === 'imprimer'
+
+    const expressions = []
+    do {
+      expressions.push(this.parseExpression(lang))
+    } while (this.match(TokenType.COMMA))
+
+    return {
+      type: isPrint ? 'PrintStatement' : 'EchoStatement',
+      expressions: expressions
+    }
+  }
+
+  parseInclude(lang) {
+    const token = this.advance()
+    const val = this.normalizeAccents(String(token.value).toLowerCase())
+
+    let includeType = 'include'
+    if (val === 'require' || val === 'requerir') {
+      includeType = 'require'
+    } else if (val === 'inclure une fois' || val === 'include_once') {
+      includeType = 'include_once'
+    } else if (val === 'require une fois' || val === 'require_once' || val === 'requerir une fois') {
+      includeType = 'require_once'
+    }
+
+    let path
+    if (this.match(TokenType.LPAREN)) {
+      path = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+    } else {
+      path = this.parseExpression(lang)
+    }
+
+    return {
+      type: 'IncludeStatement',
+      includeType: includeType,
+      path: path
+    }
+  }
+
+  parseGlobalStatement(lang) {
+    this.advance()
+    
+    const variables = []
+    do {
+      const varToken = this.current()
+      let varName = varToken ? varToken.value : ''
+      if (varName.startsWith('$')) varName = varName.substring(1)
+      this.advance()
+      variables.push(varName)
+    } while (this.match(TokenType.COMMA))
+
+    return {
+      type: 'GlobalStatement',
+      variables: variables
+    }
+  }
+
+  parseExpression(lang) {
+    return this.parseAssignment(lang)
+  }
+
+  parseAssignment(lang) {
+    let left = this.parseTernary(lang)
+
+    if (this.match(TokenType.EQUALS)) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '=', left, right }
+    }
+    if (this.match(TokenType.PLUS_EQUALS)) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '+=', left, right }
+    }
+    if (this.match(TokenType.MINUS_EQUALS)) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '-=', left, right }
+    }
+    if (this.match(TokenType.STAR_EQUALS)) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '*=', left, right }
+    }
+    if (this.match(TokenType.SLASH_EQUALS)) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '/=', left, right }
+    }
+    if (this.match(TokenType.PERCENT_EQUALS)) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '%=', left, right }
+    }
+    if (this.match(TokenType.DOT_EQUALS) || this.matchValue('.=')) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '.=', left, right }
+    }
+    if (this.match(TokenType.DOUBLE_QUESTION_EQUALS) || this.matchValue('??=')) {
+      const right = this.parseAssignment(lang)
+      return { type: 'AssignmentExpression', operator: '??=', left, right }
+    }
+
+    return left
+  }
+
+  parseTernary(lang) {
+    let condition = this.parseNullCoalesce(lang)
+
+    if (this.match(TokenType.QUESTION)) {
+      let consequent = null
+      if (!this.check(TokenType.COLON)) {
+        consequent = this.parseExpression(lang)
+      }
+      this.match(TokenType.COLON)
+      const alternate = this.parseTernary(lang)
+      return { type: 'ConditionalExpression', condition, consequent, alternate }
+    }
+
+    return condition
+  }
+
+  parseNullCoalesce(lang) {
+    let left = this.parseLogicalOr(lang)
+
+    while (this.match(TokenType.DOUBLE_QUESTION) || this.matchValue('??') || this.matchValue('coalescence')) {
+      const right = this.parseLogicalOr(lang)
+      left = { type: 'BinaryExpression', operator: '??', left, right }
+    }
+
+    return left
+  }
+
+  parseLogicalOr(lang) {
+    let left = this.parseLogicalAnd(lang)
+
+    while (this.match(TokenType.OR) || this.matchValue('ou') || this.matchValue('or')) {
+      const right = this.parseLogicalAnd(lang)
+      left = { type: 'BinaryExpression', operator: '||', left, right }
+    }
+
+    return left
+  }
+
+  parseLogicalAnd(lang) {
+    let left = this.parseEquality(lang)
+
+    while (this.match(TokenType.AND) || this.matchValue('et') || this.matchValue('and')) {
+      const right = this.parseEquality(lang)
+      left = { type: 'BinaryExpression', operator: '&&', left, right }
+    }
+
+    return left
+  }
+
+  parseEquality(lang) {
+    let left = this.parseComparison(lang)
+
+    while (true) {
+      if (this.match(TokenType.TRIPLE_EQUALS) || this.matchValue('strictement egal') || this.matchValue('===')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '===', left, right }
+      } else if (this.match(TokenType.BANG_DOUBLE_EQUALS) || this.matchValue('strictement different') || this.matchValue('!==')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '!==', left, right }
+      } else if (this.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('==')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '==', left, right }
+      } else if (this.match(TokenType.BANG_EQUALS) || this.matchValue('different') || this.matchValue('!=')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '!=', left, right }
+      } else if (this.match(TokenType.SPACESHIP) || this.matchValue('<=>')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '<=>', left, right }
+      } else {
+        break
+      }
+    }
+
+    return left
+  }
+
+  parseComparison(lang) {
+    let left = this.parseConcatenation(lang)
+
+    while (true) {
+      if (this.match(TokenType.LT) || this.matchValue('inferieur') || this.matchValue('<')) {
+        const right = this.parseConcatenation(lang)
+        left = { type: 'BinaryExpression', operator: '<', left, right }
+      } else if (this.match(TokenType.GT) || this.matchValue('superieur') || this.matchValue('>')) {
+        const right = this.parseConcatenation(lang)
+        left = { type: 'BinaryExpression', operator: '>', left, right }
+      } else if (this.match(TokenType.LTE) || this.matchValue('inferieur ou egal') || this.matchValue('<=')) {
+        const right = this.parseConcatenation(lang)
+        left = { type: 'BinaryExpression', operator: '<=', left, right }
+      } else if (this.match(TokenType.GTE) || this.matchValue('superieur ou egal') || this.matchValue('>=')) {
+        const right = this.parseConcatenation(lang)
+        left = { type: 'BinaryExpression', operator: '>=', left, right }
+      } else if (this.matchValue('instanceof') || this.matchValue('instance de')) {
+        const right = this.parseConcatenation(lang)
+        left = { type: 'BinaryExpression', operator: 'instanceof', left, right }
+      } else {
+        break
+      }
+    }
+
+    return left
+  }
+
+  parseConcatenation(lang) {
+    let left = this.parseAdditive(lang)
+
+    while (this.match(TokenType.DOT) || this.matchValue('concatener') || this.matchValue('concatenation')) {
+      const right = this.parseAdditive(lang)
+      left = { type: 'BinaryExpression', operator: '.', left, right }
+    }
+
+    return left
+  }
+
+  parseAdditive(lang) {
+    let left = this.parseMultiplicative(lang)
+
+    while (true) {
+      if (this.match(TokenType.PLUS) || this.matchValue('plus') || this.matchValue('addition')) {
+        const right = this.parseMultiplicative(lang)
+        left = { type: 'BinaryExpression', operator: '+', left, right }
+      } else if (this.match(TokenType.MINUS) || this.matchValue('moins') || this.matchValue('soustraction')) {
+        const right = this.parseMultiplicative(lang)
+        left = { type: 'BinaryExpression', operator: '-', left, right }
+      } else {
+        break
+      }
+    }
+
+    return left
+  }
+
+  parseMultiplicative(lang) {
+    let left = this.parseUnary(lang)
+
+    while (true) {
+      if (this.match(TokenType.STAR) || this.matchValue('fois') || this.matchValue('multiplication')) {
+        const right = this.parseUnary(lang)
+        left = { type: 'BinaryExpression', operator: '*', left, right }
+      } else if (this.match(TokenType.SLASH) || this.matchValue('divise') || this.matchValue('division')) {
+        const right = this.parseUnary(lang)
+        left = { type: 'BinaryExpression', operator: '/', left, right }
+      } else if (this.match(TokenType.PERCENT) || this.matchValue('modulo')) {
+        const right = this.parseUnary(lang)
+        left = { type: 'BinaryExpression', operator: '%', left, right }
+      } else if (this.match(TokenType.DOUBLE_STAR) || this.matchValue('puissance') || this.matchValue('**')) {
+        const right = this.parseUnary(lang)
+        left = { type: 'BinaryExpression', operator: '**', left, right }
+      } else {
+        break
+      }
+    }
+
+    return left
+  }
+
+  parseUnary(lang) {
+    if (this.match(TokenType.BANG) || this.matchValue('non') || this.matchValue('pas')) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UnaryExpression', operator: '!', operand }
+    }
+
+    if (this.match(TokenType.MINUS)) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UnaryExpression', operator: '-', operand }
+    }
+
+    if (this.match(TokenType.PLUS)) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UnaryExpression', operator: '+', operand }
+    }
+
+    if (this.match(TokenType.AT)) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UnaryExpression', operator: '@', operand }
+    }
+
+    if (this.match(TokenType.TILDE)) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UnaryExpression', operator: '~', operand }
+    }
+
+    if (this.match(TokenType.DOUBLE_PLUS)) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UpdateExpression', operator: '++', prefix: true, operand }
+    }
+
+    if (this.match(TokenType.DOUBLE_MINUS)) {
+      const operand = this.parseUnary(lang)
+      return { type: 'UpdateExpression', operator: '--', prefix: true, operand }
+    }
+
+    if (this.matchValue('nouveau') || this.matchValue('nouvelle') || this.matchValue('new')) {
+      return this.parseNew(lang)
+    }
+
+    if (this.matchValue('clone') || this.matchValue('cloner')) {
+      const operand = this.parseUnary(lang)
+      return { type: 'CloneExpression', operand }
+    }
+
+    if (this.matchValue('rendement') || this.matchValue('yield')) {
+      let delegate = false
+      if (this.matchValue('de') || this.matchValue('from')) {
+        delegate = true
+      }
+      const argument = this.parseExpression(lang)
+      return { type: 'YieldExpression', argument, delegate }
+    }
+
+    const castTypes = ['int', 'integer', 'entier', 'float', 'double', 'flottant', 'string', 'chaine', 'bool', 'boolean', 'booleen', 'array', 'tableau', 'object', 'objet', 'unset']
+    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (this.check(TokenType.LPAREN)) {
+      const next = this.peek(1)
+      if (next && castTypes.includes(this.normalizeAccents(String(next.value).toLowerCase()))) {
+        this.advance()
+        const castType = this.translateType(this.advance().value)
+        this.match(TokenType.RPAREN)
+        const operand = this.parseUnary(lang)
+        return { type: 'CastExpression', castType, operand }
+      }
+    }
+
+    return this.parsePostfix(lang)
+  }
+
+  parseNew(lang) {
+    let className
+    
+    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (val === 'classe' || val === 'class') {
+      this.advance()
+      
+      let superClass = null
+      const extendsVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (['etendre', 'etend', 'extends'].includes(extendsVal)) {
+        this.advance()
+        superClass = this.parseNamespacePath(lang)
+      }
+
+      const interfaces = []
+      const implementsVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (['implementer', 'implemente', 'implements'].includes(implementsVal)) {
+        this.advance()
+        do {
+          interfaces.push(this.parseNamespacePath(lang))
+        } while (this.match(TokenType.COMMA))
+      }
+
+      let args = []
+      if (this.check(TokenType.LPAREN)) {
+        this.advance()
+        while (!this.isAtEnd() && !this.check(TokenType.RPAREN)) {
+          args.push(this.parseExpression(lang))
+          this.match(TokenType.COMMA)
+        }
+        this.match(TokenType.RPAREN)
+      }
+
+      this.skipNewlines()
+      const body = this.parseClassBody(lang)
+
+      return {
+        type: 'NewExpression',
+        callee: {
+          type: 'AnonymousClass',
+          superClass: superClass,
+          interfaces: interfaces,
+          body: body
+        },
+        arguments: args
+      }
+    }
+
+    className = this.parseNamespacePath(lang)
+    
+    let args = []
+    if (this.check(TokenType.LPAREN)) {
+      this.advance()
+      while (!this.isAtEnd() && !this.check(TokenType.RPAREN)) {
+        this.skipNewlines()
+        if (this.check(TokenType.RPAREN)) break
+        args.push(this.parseExpression(lang))
+        this.match(TokenType.COMMA)
+        this.skipNewlines()
+      }
+      this.match(TokenType.RPAREN)
+    }
+
+    return {
+      type: 'NewExpression',
+      callee: { type: 'Identifier', name: className },
+      arguments: args
+    }
+  }
+
+  parsePostfix(lang) {
+    let expr = this.parseCall(lang)
+
+    if (this.match(TokenType.DOUBLE_PLUS)) {
+      return { type: 'UpdateExpression', operator: '++', prefix: false, operand: expr }
+    }
+
+    if (this.match(TokenType.DOUBLE_MINUS)) {
+      return { type: 'UpdateExpression', operator: '--', prefix: false, operand: expr }
+    }
+
+    return expr
+  }
+
+  parseCall(lang) {
+    let expr = this.parsePrimary(lang)
+
+    while (true) {
+      if (this.match(TokenType.LPAREN)) {
+        const args = []
+        while (!this.isAtEnd() && !this.check(TokenType.RPAREN)) {
+          this.skipNewlines()
+          if (this.check(TokenType.RPAREN)) break
+          
+          if (this.match(TokenType.SPREAD) || this.matchValue('...')) {
+            const arg = this.parseExpression(lang)
+            args.push({ type: 'SpreadElement', argument: arg })
+          } else {
+            let argName = null
+            if (this.current() && this.current().type === TokenType.IDENTIFIER) {
+              const next = this.peek(1)
+              if (next && next.type === TokenType.COLON) {
+                argName = this.advance().value
+                this.advance()
+              }
+            }
+            const arg = this.parseExpression(lang)
+            if (argName) {
+              args.push({ type: 'NamedArgument', name: argName, value: arg })
+            } else {
+              args.push(arg)
+            }
+          }
+          this.match(TokenType.COMMA)
+          this.skipNewlines()
+        }
+        this.match(TokenType.RPAREN)
+        expr = { type: 'CallExpression', callee: expr, arguments: args }
+      } else if (this.match(TokenType.ARROW) || this.matchValue('->')) {
+        const property = this.current()
+        if (property && property.type === TokenType.IDENTIFIER) {
+          this.advance()
+          expr = { type: 'MemberExpression', object: expr, property: { type: 'Identifier', name: property.value }, operator: '->' }
+        } else if (this.match(TokenType.LBRACE)) {
+          const propExpr = this.parseExpression(lang)
+          this.match(TokenType.RBRACE)
+          expr = { type: 'MemberExpression', object: expr, property: propExpr, computed: true, operator: '->' }
+        }
+      } else if (this.match(TokenType.NULLSAFE_ARROW) || this.matchValue('?->')) {
+        const property = this.current()
+        if (property && property.type === TokenType.IDENTIFIER) {
+          this.advance()
+          expr = { type: 'MemberExpression', object: expr, property: { type: 'Identifier', name: property.value }, operator: '?->', nullsafe: true }
+        }
+      } else if (this.match(TokenType.DOUBLE_COLON) || this.matchValue('::')) {
+        const member = this.current()
+        if (member && member.type === TokenType.IDENTIFIER) {
+          this.advance()
+          expr = { type: 'StaticMemberExpression', class: expr, member: { type: 'Identifier', name: member.value } }
+        } else if (member && member.value === 'class') {
+          this.advance()
+          expr = { type: 'ClassNameExpression', class: expr }
+        }
+      } else if (this.match(TokenType.LBRACKET)) {
+        const index = this.check(TokenType.RBRACKET) ? null : this.parseExpression(lang)
+        this.match(TokenType.RBRACKET)
+        expr = { type: 'IndexExpression', object: expr, index }
+      } else {
+        break
+      }
+    }
+
+    return expr
+  }
+
+  parsePrimary(lang) {
+    const token = this.current()
+
+    if (!token) {
+      return { type: 'Literal', value: null }
+    }
+
+    if (token.type === TokenType.NUMBER || token.type === TokenType.INTEGER || token.type === TokenType.FLOAT) {
+      this.advance()
+      return { type: 'Literal', value: parseFloat(token.value) }
+    }
+
+    if (token.type === TokenType.STRING) {
+      this.advance()
+      let value = token.value
+      if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1)
+      }
+      const isDouble = token.value.startsWith('"')
+      return { type: 'StringLiteral', value, doubleQuoted: isDouble }
+    }
+
+    if (token.type === TokenType.HEREDOC || token.type === TokenType.NOWDOC) {
+      this.advance()
+      return { type: 'HeredocLiteral', value: token.value }
+    }
+
+    if (token.type === TokenType.IDENTIFIER) {
+      const value = token.value
+      const valueLower = this.normalizeAccents(value.toLowerCase())
+
+      if (valueLower === 'vrai' || valueLower === 'true') {
+        this.advance()
+        return { type: 'Literal', value: true }
+      }
+
+      if (valueLower === 'faux' || valueLower === 'false') {
+        this.advance()
+        return { type: 'Literal', value: false }
+      }
+
+      if (valueLower === 'nul' || valueLower === 'null' || valueLower === 'rien') {
+        this.advance()
+        return { type: 'Literal', value: null }
+      }
+
+      if (valueLower === 'ceci' || valueLower === 'this') {
+        this.advance()
+        return { type: 'ThisExpression' }
+      }
+
+      if (valueLower === 'self') {
+        this.advance()
+        return { type: 'Identifier', name: 'self' }
+      }
+
+      if (valueLower === 'parent') {
+        this.advance()
+        return { type: 'Identifier', name: 'parent' }
+      }
+
+      if (valueLower === 'static' || valueLower === 'statique') {
+        this.advance()
+        return { type: 'Identifier', name: 'static' }
+      }
+
+      if (['fonction', 'function'].includes(valueLower)) {
+        return this.parseFunctionExpression(lang)
+      }
+
+      if (valueLower === 'fn') {
+        return this.parseArrowFunction(lang)
+      }
+
+      if (valueLower === 'match') {
+        return this.parseMatchExpression(lang)
+      }
+
+      if (value.startsWith('$')) {
+        this.advance()
+        return { type: 'Variable', name: value.substring(1) }
+      }
+
+      const translated = this.translatePHP(value)
+      this.advance()
+      return { type: 'Identifier', name: translated || value }
+    }
+
+    if (token.type === TokenType.VARIABLE) {
+      this.advance()
+      let name = token.value
+      if (name.startsWith('$')) name = name.substring(1)
+      return { type: 'Variable', name }
+    }
+
+    if (token.type === TokenType.LBRACKET) {
+      return this.parseArrayLiteral(lang)
+    }
+
+    if (token.type === TokenType.LPAREN) {
+      this.advance()
+      const expr = this.parseExpression(lang)
+      this.match(TokenType.RPAREN)
+      expr.parenthesized = true
+      return expr
+    }
+
+    this.advance()
+    return { type: 'Literal', value: null }
+  }
+
+  parseFunctionExpression(lang) {
+    this.advance()
+
+    let isReference = false
+    if (this.match(TokenType.AMPERSAND)) {
+      isReference = true
+    }
+
+    const params = this.parseParameters(lang)
+
+    let uses = []
+    const useVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+    if (useVal === 'utiliser' || useVal === 'use') {
+      this.advance()
+      uses = this.parseClosureUse(lang)
+    }
+
+    let returnType = null
+    if (this.match(TokenType.COLON)) {
+      let nullable = false
+      if (this.match(TokenType.QUESTION)) {
+        nullable = true
+      }
+      returnType = this.parseTypeHint(lang)
+      if (returnType && nullable) {
+        returnType.nullable = true
+      }
+    }
+
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+
+    return {
+      type: 'FunctionExpression',
+      params: params,
+      uses: uses,
+      returnType: returnType,
+      body: body,
+      reference: isReference
+    }
+  }
+
+  parseArrowFunction(lang) {
+    this.advance()
+
+    const params = this.parseParameters(lang)
+
+    let returnType = null
+    if (this.match(TokenType.COLON)) {
+      returnType = this.parseTypeHint(lang)
+    }
+
+    this.match(TokenType.DOUBLE_ARROW) || this.matchValue('=>')
+
+    const body = this.parseExpression(lang)
+
+    return {
+      type: 'ArrowFunctionExpression',
+      params: params,
+      returnType: returnType,
+      body: body
+    }
+  }
+
+  parseArrayLiteral(lang) {
+    this.match(TokenType.LBRACKET)
+    const elements = []
+
+    while (!this.isAtEnd() && !this.check(TokenType.RBRACKET)) {
+      this.skipNewlines()
+      if (this.check(TokenType.RBRACKET)) break
+
+      if (this.match(TokenType.SPREAD) || this.matchValue('...')) {
+        const argument = this.parseExpression(lang)
+        elements.push({ type: 'SpreadElement', argument })
+      } else {
+        const first = this.parseExpression(lang)
+        
+        if (this.match(TokenType.DOUBLE_ARROW) || this.matchValue('=>')) {
+          const value = this.parseExpression(lang)
+          elements.push({ type: 'ArrayElement', key: first, value })
+        } else {
+          elements.push({ type: 'ArrayElement', key: null, value: first })
+        }
+      }
+
+      this.match(TokenType.COMMA)
+      this.skipNewlines()
+    }
+
+    this.match(TokenType.RBRACKET)
+    return { type: 'ArrayExpression', elements }
+  }
+}
+
+module.exports = { EtherParserPHP }