ether-code 0.9.0 → 0.9.1

package/parsers/ether-parser-php.js

@@ -226,12 +226,6 @@ class EtherParserPHP extends EtherParserBase {
     this.phpModifiers = ['statique', 'static', 'final', 'finale', 'abstrait', 'abstraite', 'abstract', 'readonly', 'lecture seule']
   }
 
-  safeStr(val) {
-    if (typeof val === 'string') return val
-    if (val && typeof val === 'object') return String(val.name || val.value || '')
-    return String(val || '')
-  }
-
   translatePHP(word) {
     if (!word) return word
     const lower = this.normalizeAccents(String(word))
@@ -278,10 +272,6 @@ class EtherParserPHP extends EtherParserBase {
 
     const value = token.value != null ? this.normalizeAccents(String(token.value).toLowerCase()) : ''
 
-    if (this.isDeclare(value)) {
-      return this.parseDeclare(lang)
-    }
-
     if (this.isNamespace(value)) {
       return this.parseNamespace(lang)
     }
@@ -290,6 +280,10 @@ class EtherParserPHP extends EtherParserBase {
       return this.parseUseStatement(lang)
     }
 
+    if (this.isDeclare(value)) {
+      return this.parseDeclareStatement(lang)
+    }
+
     if (this.isClassDeclaration(value)) {
       return this.parseClassDeclaration(lang)
     }
@@ -326,16 +320,6 @@ class EtherParserPHP extends EtherParserBase {
       return this.parseSwitch(lang)
     }
 
-    if (token.type === TokenType.IDENTIFIER) {
-      const multiWordCall = this.tryParseMultiWordCallFromStart(lang)
-      if (multiWordCall) {
-        return {
-          type: 'ExpressionStatement',
-          expression: multiWordCall
-        }
-      }
-    }
-
     if (this.isTry(value)) {
       return this.parseTryStatement(lang)
     }
@@ -385,23 +369,17 @@ class EtherParserPHP extends EtherParserBase {
   }
 
   isNamespace(value) {
-    if (value === 'namespace' || value === 'espace de noms') return true
-    if (value === 'espace') {
-      const next1 = this.peek(1)
-      const next2 = this.peek(2)
-      if (next1 && next2) {
-        const val1 = this.normalizeAccents(String(next1.value).toLowerCase())
-        const val2 = this.normalizeAccents(String(next2.value).toLowerCase())
-        if (val1 === 'de' && val2 === 'noms') return true
-      }
-    }
-    return false
+    return ['namespace', 'espace de noms'].includes(value)
   }
 
   isUse(value) {
     return ['utiliser', 'use'].includes(value)
   }
 
+  isDeclare(value) {
+    return ['declarer', 'declare'].includes(value)
+  }
+
   isClassDeclaration(value) {
     const keywords = ['classe', 'class', 'abstrait', 'abstraite', 'abstract', 'final', 'finale', 'readonly']
     if (keywords.includes(value)) {
@@ -493,54 +471,8 @@ class EtherParserPHP extends EtherParserBase {
     return value === 'match'
   }
 
-  isDeclare(value) {
-    return ['declare', 'declarer', 'déclarer'].includes(value)
-  }
-
-  parseDeclare(lang) {
-    this.advance()
-    
-    const directives = []
-    
-    if (this.match(TokenType.LPAREN)) {
-      do {
-        const nameToken = this.current()
-        const name = nameToken ? this.safeStr(nameToken.value) : ''
-        this.advance()
-        
-        this.match(TokenType.EQUALS)
-        
-        const value = this.parseExpression(lang)
-        directives.push({ name, value })
-      } while (this.match(TokenType.COMMA))
-      
-      this.match(TokenType.RPAREN)
-    } else {
-      const nameToken = this.current()
-      const name = nameToken ? this.safeStr(nameToken.value) : ''
-      this.advance()
-      
-      this.match(TokenType.EQUALS)
-      
-      const value = this.parseExpression(lang)
-      directives.push({ name, value })
-    }
-    
-    return {
-      type: 'DeclareStatement',
-      directives: directives
-    }
-  }
-
   parseNamespace(lang) {
-    const first = this.advance()
-    const firstVal = this.normalizeAccents(String(first.value).toLowerCase())
-    
-    if (firstVal === 'espace' && firstVal !== 'espace de noms') {
-      this.advance()
-      this.advance()
-    }
-    
+    this.advance()
     const name = this.parseNamespacePath(lang)
     this.skipNewlines()
     
@@ -608,6 +540,42 @@ class EtherParserPHP extends EtherParserBase {
     }
   }
 
+  parseDeclareStatement(lang) {
+    this.advance()
+    
+    const directives = []
+    
+    do {
+      const nameToken = this.current()
+      if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) break
+      
+      let name = String(nameToken.value)
+      this.advance()
+      
+      if (name === 'strict' && this.current()) {
+        const next = this.normalizeAccents(String(this.current().value).toLowerCase())
+        if (next === 'types' || next === '_types') {
+          name = 'strict_types'
+          this.advance()
+        }
+      }
+      
+      this.match(TokenType.EQUALS)
+      
+      const value = this.parseExpression(lang)
+      
+      directives.push({
+        name: name,
+        value: value
+      })
+    } while (this.match(TokenType.COMMA))
+    
+    return {
+      type: 'DeclareStatement',
+      directives: directives
+    }
+  }
+
   parseClassDeclaration(lang) {
     const modifiers = []
 
@@ -743,6 +711,10 @@ class EtherParserPHP extends EtherParserBase {
       return this.parseTraitUse(lang)
     }
 
+    if (val === 'variable' || val === 'var') {
+      this.advance()
+    }
+
     return this.parsePropertyDeclaration(lang, visibility, isStatic, isReadonly)
   }
 
@@ -803,11 +775,6 @@ class EtherParserPHP extends EtherParserBase {
   }
 
   parsePropertyDeclaration(lang, visibility, isStatic, isReadonly) {
-    const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
-    if (val === 'variable' || val === 'var') {
-      this.advance()
-    }
-
     let typeHint = null
 
     const current = this.current()
@@ -819,10 +786,12 @@ class EtherParserPHP extends EtherParserBase {
     }
 
     const nameToken = this.current()
-    let name = this.safeStr(nameToken ? nameToken.value : 'property')
+    let name = nameToken ? nameToken.value : 'property'
     
-    if (name.startsWith('$')) {
+    if (typeof name === 'string' && name.startsWith('$')) {
       name = name.substring(1)
+    } else if (typeof name !== 'string') {
+      name = String(name)
     }
     
     if (nameToken) this.advance()
@@ -1091,6 +1060,7 @@ class EtherParserPHP extends EtherParserBase {
       }
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
 
     let body
@@ -1109,8 +1079,6 @@ class EtherParserPHP extends EtherParserBase {
       }
     }
 
-    this.match(TokenType.COLON)
-    this.skipNewlines()
     body = this.parseBlock(lang)
 
     return {
@@ -1135,7 +1103,7 @@ class EtherParserPHP extends EtherParserBase {
       }
       
       const varToken = this.current()
-      let varName = this.safeStr(varToken ? varToken.value : '')
+      let varName = varToken ? String(varToken.value) : ''
       if (varName.startsWith('$')) {
         varName = varName.substring(1)
       }
@@ -1180,7 +1148,6 @@ class EtherParserPHP extends EtherParserBase {
     let variadic = false
     let byReference = false
     let defaultValue = null
-    let name = null
 
     const val = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
     if (this.phpVisibility.includes(val)) {
@@ -1194,6 +1161,19 @@ class EtherParserPHP extends EtherParserBase {
       this.advance()
     }
 
+    const currentType = this.current()
+    if (currentType && currentType.type === TokenType.IDENTIFIER) {
+      const typeLower = this.normalizeAccents(String(currentType.value).toLowerCase())
+      const nextToken = this.peek(1)
+      
+      if (nextToken && nextToken.type === TokenType.COLON) {
+      } else if (this.phpTypes[typeLower] || (typeLower[0] && typeLower[0] === typeLower[0].toUpperCase())) {
+        if (!nextToken || nextToken.type !== TokenType.EQUALS) {
+          typeHint = this.parseTypeHint(lang)
+        }
+      }
+    }
+
     if (this.match(TokenType.SPREAD) || this.matchValue('...')) {
       variadic = true
     }
@@ -1202,33 +1182,17 @@ class EtherParserPHP extends EtherParserBase {
       byReference = true
     }
 
-    const currentToken = this.current()
-    if (!currentToken) return null
-
-    const nextToken = this.peek(1)
+    const nameToken = this.current()
+    if (!nameToken) return null
     
-    if (nextToken && nextToken.type === TokenType.COLON) {
-      name = this.safeStr(currentToken.value)
-      if (name.startsWith('$')) name = name.substring(1)
-      this.advance()
-      this.advance()
-      typeHint = this.parseTypeHint(lang)
-    } else {
-      const typeLower = this.normalizeAccents(String(currentToken.value).toLowerCase())
-      if (this.phpTypes[typeLower] || /^[A-Z]/.test(currentToken.value)) {
-        typeHint = this.parseTypeHint(lang)
-      }
-      
-      const nameToken = this.current()
-      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-        name = this.safeStr(nameToken.value)
-        if (name.startsWith('$')) name = name.substring(1)
-        this.advance()
-      }
+    let name = String(nameToken.value)
+    if (name.startsWith('$')) {
+      name = name.substring(1)
     }
+    this.advance()
 
-    if (!name) {
-      name = 'param'
+    if (this.match(TokenType.COLON)) {
+      typeHint = this.parseTypeHint(lang)
     }
 
     if (this.match(TokenType.EQUALS)) {
@@ -1317,7 +1281,7 @@ class EtherParserPHP extends EtherParserBase {
     }
 
     const nameToken = this.current()
-    let name = this.safeStr(nameToken ? nameToken.value : 'variable')
+    let name = nameToken ? String(nameToken.value) : 'variable'
     if (name.startsWith('$')) {
       name = name.substring(1)
     }
@@ -1357,37 +1321,59 @@ class EtherParserPHP extends EtherParserBase {
     
     const elseVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
     if (elseVal === 'sinon si' || elseVal === 'elseif') {
-      alternate = this.parseConditional(lang)
-      alternate.type = 'IfStatement'
-    } else if (elseVal === 'sinon') {
+      this.advance()
+      
+      let elseCondition
+      if (this.match(TokenType.LPAREN)) {
+        elseCondition = this.parseExpression(lang)
+        this.match(TokenType.RPAREN)
+      } else {
+        elseCondition = this.parseConditionUntilColon(lang)
+      }
+      
+      this.match(TokenType.COLON)
+      this.skipNewlines()
+      const elseConsequent = this.parseBlock(lang)
+      
+      alternate = {
+        type: 'IfStatement',
+        condition: elseCondition,
+        consequent: elseConsequent,
+        alternate: null
+      }
+      
+      this.skipNewlines()
+      const nextElse = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+      if (nextElse === 'sinon' || nextElse === 'else') {
+        this.advance()
+        this.match(TokenType.COLON)
+        this.skipNewlines()
+        alternate.alternate = this.parseBlock(lang)
+      }
+    } 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 = 'IfStatement'
+        alternate.type = 'ElseIfStatement'
       } else {
         this.match(TokenType.COLON)
         this.skipNewlines()
         alternate = this.parseBlock(lang)
       }
-    } else if (elseVal === 'else') {
-      this.advance()
-      this.match(TokenType.COLON)
-      this.skipNewlines()
-      alternate = this.parseBlock(lang)
     }
 
     return {
       type: 'IfStatement',
-      test: condition,
+      condition: condition,
       consequent: consequent,
       alternate: alternate
     }
   }
 
   parseConditionUntilColon(lang) {
-    const startPos = this.pos
+    const tokens = []
     let depth = 0
     
     while (!this.isAtEnd()) {
@@ -1404,23 +1390,36 @@ class EtherParserPHP extends EtherParserBase {
         break
       }
       
+      tokens.push(token)
       this.advance()
     }
     
-    const endPos = this.pos
-    this.pos = startPos
-    
-    if (endPos > startPos) {
-      return this.parseExpression(lang)
+    if (tokens.length === 0) {
+      return { type: 'Literal', value: true }
     }
     
-    return { type: 'Literal', value: true }
+    const savedPos = this.pos
+    const savedTokens = this.tokens
+    this.tokens = tokens
+    this.pos = 0
+    
+    const expr = this.parseExpression(lang)
+    
+    this.tokens = savedTokens
+    this.pos = savedPos
+    
+    return expr
   }
 
   parseLoop(lang) {
     const token = this.current()
     const value = this.normalizeAccents(String(token.value).toLowerCase())
 
+    if (value === 'pour chaque' || value === 'foreach') {
+      this.advance()
+      return this.parseForeach(lang)
+    }
+
     if (value === 'pour') {
       const next = this.peek(1)
       if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'chaque') {
@@ -1431,16 +1430,14 @@ class EtherParserPHP extends EtherParserBase {
       return this.parseFor(lang)
     }
 
-    if (value === 'foreach' || value === 'pour chaque') {
+    if (value === 'tant que' || value === 'while') {
       this.advance()
-      return this.parseForeach(lang)
+      return this.parseWhile(lang)
     }
 
-    if (value === 'while' || value === 'tant') {
+    if (value === 'tant') {
       this.advance()
-      if (value === 'tant') {
-        this.matchValue('que')
-      }
+      this.matchValue('que')
       return this.parseWhile(lang)
     }
 
@@ -1454,7 +1451,7 @@ class EtherParserPHP extends EtherParserBase {
 
   parseFor(lang) {
     this.advance()
-    
+
     let init = null
     let test = null
     let update = null
@@ -1475,19 +1472,13 @@ class EtherParserPHP extends EtherParserBase {
       }
       this.match(TokenType.RPAREN)
     } else {
-      if (!this.check(TokenType.SEMICOLON) && !this.check(TokenType.COLON)) {
-        init = this.parseExpression(lang)
-      }
+      init = this.parseForInitUntilSemicolon(lang)
       this.match(TokenType.SEMICOLON)
       
-      if (!this.check(TokenType.SEMICOLON) && !this.check(TokenType.COLON)) {
-        test = this.parseExpression(lang)
-      }
+      test = this.parseForConditionUntilSemicolon(lang)
       this.match(TokenType.SEMICOLON)
       
-      if (!this.check(TokenType.COLON) && !this.check(TokenType.NEWLINE)) {
-        update = this.parseExpression(lang)
-      }
+      update = this.parseForUpdateUntilColon(lang)
     }
 
     this.match(TokenType.COLON)
@@ -1503,6 +1494,82 @@ class EtherParserPHP extends EtherParserBase {
     }
   }
 
+  parseForInitUntilSemicolon(lang) {
+    const tokens = []
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      if (!token) break
+      if (token.type === TokenType.SEMICOLON) break
+      tokens.push(token)
+      this.advance()
+    }
+    
+    if (tokens.length === 0) return null
+    
+    const savedPos = this.pos
+    const savedTokens = this.tokens
+    this.tokens = tokens
+    this.pos = 0
+    
+    const expr = this.parseExpression(lang)
+    
+    this.tokens = savedTokens
+    this.pos = savedPos
+    
+    return expr
+  }
+
+  parseForConditionUntilSemicolon(lang) {
+    const tokens = []
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      if (!token) break
+      if (token.type === TokenType.SEMICOLON) break
+      tokens.push(token)
+      this.advance()
+    }
+    
+    if (tokens.length === 0) return null
+    
+    const savedPos = this.pos
+    const savedTokens = this.tokens
+    this.tokens = tokens
+    this.pos = 0
+    
+    const expr = this.parseExpression(lang)
+    
+    this.tokens = savedTokens
+    this.pos = savedPos
+    
+    return expr
+  }
+
+  parseForUpdateUntilColon(lang) {
+    const tokens = []
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      if (!token) break
+      if (token.type === TokenType.COLON) break
+      if (token.type === TokenType.NEWLINE) break
+      tokens.push(token)
+      this.advance()
+    }
+    
+    if (tokens.length === 0) return null
+    
+    const savedPos = this.pos
+    const savedTokens = this.tokens
+    this.tokens = tokens
+    this.pos = 0
+    
+    const expr = this.parseExpression(lang)
+    
+    this.tokens = savedTokens
+    this.pos = savedPos
+    
+    return expr
+  }
+
   parseForeach(lang) {
     let array = null
     let key = null
@@ -1522,7 +1589,7 @@ class EtherParserPHP extends EtherParserBase {
       }
 
       const firstVar = this.current()
-      let firstName = this.safeStr(firstVar ? firstVar.value : 'item')
+      let firstName = firstVar ? String(firstVar.value) : 'item'
       if (firstName.startsWith('$')) firstName = firstName.substring(1)
       this.advance()
 
@@ -1534,7 +1601,7 @@ class EtherParserPHP extends EtherParserBase {
         }
         
         const valueVar = this.current()
-        value = this.safeStr(valueVar ? valueVar.value : 'value')
+        value = valueVar ? String(valueVar.value) : 'value'
         if (value.startsWith('$')) value = value.substring(1)
         this.advance()
       } else {
@@ -1543,12 +1610,28 @@ class EtherParserPHP extends EtherParserBase {
 
       this.match(TokenType.RPAREN)
     } else {
-      const arrayToken = this.current()
-      if (arrayToken) {
-        array = { type: 'Identifier', name: this.safeStr(arrayToken.value) }
+      const tokens = []
+      while (!this.isAtEnd()) {
+        const token = this.current()
+        if (!token) break
+        const tokenVal = this.normalizeAccents(String(token.value).toLowerCase())
+        if (tokenVal === 'comme' || tokenVal === 'as') break
+        if (token.type === TokenType.COLON) break
+        if (token.type === TokenType.NEWLINE) break
+        tokens.push(token)
         this.advance()
       }
       
+      if (tokens.length > 0) {
+        const savedPos = this.pos
+        const savedTokens = this.tokens
+        this.tokens = tokens
+        this.pos = 0
+        array = this.parseExpression(lang)
+        this.tokens = savedTokens
+        this.pos = savedPos
+      }
+      
       const asVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
       if (asVal === 'comme' || asVal === 'as') {
         this.advance()
@@ -1559,23 +1642,27 @@ class EtherParserPHP extends EtherParserBase {
       }
 
       const firstVar = this.current()
-      let firstName = this.safeStr(firstVar ? firstVar.value : 'item')
-      if (firstName.startsWith('$')) firstName = firstName.substring(1)
-      this.advance()
+      if (firstVar && firstVar.type === TokenType.IDENTIFIER) {
+        let firstName = String(firstVar.value)
+        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
+        if (this.match(TokenType.DOUBLE_ARROW) || this.matchValue('=>')) {
+          key = firstName
+          
+          if (this.match(TokenType.AMPERSAND)) {
+            byRef = true
+          }
+          
+          const valueVar = this.current()
+          if (valueVar && valueVar.type === TokenType.IDENTIFIER) {
+            value = String(valueVar.value)
+            if (value.startsWith('$')) value = value.substring(1)
+            this.advance()
+          }
+        } else {
+          value = firstName
         }
-        
-        const valueVar = this.current()
-        value = this.safeStr(valueVar ? valueVar.value : 'value')
-        if (value.startsWith('$')) value = value.substring(1)
-        this.advance()
-      } else {
-        value = firstName
       }
     }
 
@@ -1608,7 +1695,7 @@ class EtherParserPHP extends EtherParserBase {
 
     return {
       type: 'WhileStatement',
-      test: condition,
+      condition: condition,
       body: body
     }
   }
@@ -1686,25 +1773,29 @@ class EtherParserPHP extends EtherParserBase {
 
       if (val === 'cas' || val === 'case') {
         this.advance()
-        const test = this.parseExpression(lang)
+        const test = this.parseConditionUntilColon(lang)
         this.match(TokenType.COLON)
         this.skipNewlines()
-        this.match(TokenType.INDENT)
         
+        const hasInnerIndent = this.match(TokenType.INDENT)
         const consequent = []
+        
         while (!this.isAtEnd()) {
           this.skipNewlines()
-          const cur = this.current()
-          if (!cur) break
+          const nextToken = this.current()
+          if (!nextToken) break
           
-          const nextVal = this.normalizeAccents(String(cur.value).toLowerCase())
-          if (['cas', 'case', 'defaut', 'default'].includes(nextVal)) {
+          const nextVal = this.normalizeAccents(String(nextToken.value).toLowerCase())
+          if (['cas', 'case', 'defaut', 'default', 'défaut'].includes(nextVal)) {
             break
           }
-          if (cur.type === TokenType.RBRACE || cur.type === TokenType.DEDENT) {
-            this.advance()
+          if (nextToken.type === TokenType.RBRACE || nextToken.type === TokenType.DEDENT) {
+            if (hasInnerIndent) {
+              this.advance()
+            }
             break
           }
+          
           const stmt = this.parseStatement(lang)
           if (stmt) consequent.push(stmt)
           this.skipNewlines()
@@ -1715,21 +1806,26 @@ class EtherParserPHP extends EtherParserBase {
           test: test,
           consequent: consequent
         })
-      } else if (val === 'defaut' || val === 'default') {
+      } else if (val === 'defaut' || val === 'default' || val === 'défaut') {
         this.advance()
         this.match(TokenType.COLON)
         this.skipNewlines()
-        this.match(TokenType.INDENT)
         
+        const hasInnerIndent = this.match(TokenType.INDENT)
         const consequent = []
+        
         while (!this.isAtEnd()) {
           this.skipNewlines()
-          const cur = this.current()
-          if (!cur) break
-          if (cur.type === TokenType.RBRACE || cur.type === TokenType.DEDENT) {
-            this.advance()
+          const nextToken = this.current()
+          if (!nextToken) break
+          
+          if (nextToken.type === TokenType.RBRACE || nextToken.type === TokenType.DEDENT) {
+            if (hasInnerIndent) {
+              this.advance()
+            }
             break
           }
+          
           const stmt = this.parseStatement(lang)
           if (stmt) consequent.push(stmt)
           this.skipNewlines()
@@ -1833,7 +1929,7 @@ class EtherParserPHP extends EtherParserBase {
         do {
           const typeToken = this.current()
           if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
-            const typeName = this.safeStr(typeToken.value)
+            const typeName = String(typeToken.value)
             if (typeName.startsWith('$')) {
               param = typeName.substring(1)
             } else {
@@ -1846,7 +1942,7 @@ class EtherParserPHP extends EtherParserBase {
         if (!param) {
           const paramToken = this.current()
           if (paramToken && paramToken.type === TokenType.IDENTIFIER) {
-            param = this.safeStr(paramToken.value)
+            param = String(paramToken.value)
             if (param.startsWith('$')) param = param.substring(1)
             this.advance()
           }
@@ -1855,7 +1951,7 @@ class EtherParserPHP extends EtherParserBase {
       } else {
         const typeToken = this.current()
         if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
-          types.push(this.safeStr(typeToken.value))
+          types.push(String(typeToken.value))
           this.advance()
         }
         
@@ -1864,7 +1960,7 @@ class EtherParserPHP extends EtherParserBase {
           this.advance()
           const paramToken = this.current()
           if (paramToken && paramToken.type === TokenType.IDENTIFIER) {
-            param = this.safeStr(paramToken.value)
+            param = String(paramToken.value)
             if (param.startsWith('$')) param = param.substring(1)
             this.advance()
           }
@@ -1979,7 +2075,7 @@ class EtherParserPHP extends EtherParserBase {
     const variables = []
     do {
       const varToken = this.current()
-      let varName = this.safeStr(varToken ? varToken.value : '')
+      let varName = varToken ? String(varToken.value) : ''
       if (varName.startsWith('$')) varName = varName.substring(1)
       this.advance()
       variables.push(varName)
@@ -2196,12 +2292,12 @@ class EtherParserPHP extends EtherParserBase {
       return { type: 'UnaryExpression', operator: '!', operand }
     }
 
-    if (this.match(TokenType.MINUS) && !this.check(TokenType.MINUS)) {
+    if (this.match(TokenType.MINUS)) {
       const operand = this.parseUnary(lang)
       return { type: 'UnaryExpression', operator: '-', operand }
     }
 
-    if (this.match(TokenType.PLUS) && !this.check(TokenType.PLUS)) {
+    if (this.match(TokenType.PLUS)) {
       const operand = this.parseUnary(lang)
       return { type: 'UnaryExpression', operator: '+', operand }
     }
@@ -2216,15 +2312,12 @@ class EtherParserPHP extends EtherParserBase {
       return { type: 'UnaryExpression', operator: '~', operand }
     }
 
-    const current = this.current()
-    if (current && current.type === TokenType.PLUS && current.value === '++') {
-      this.advance()
+    if (this.match(TokenType.DOUBLE_PLUS)) {
       const operand = this.parseUnary(lang)
       return { type: 'UpdateExpression', operator: '++', prefix: true, operand }
     }
 
-    if (current && current.type === TokenType.MINUS && current.value === '--') {
-      this.advance()
+    if (this.match(TokenType.DOUBLE_MINUS)) {
       const operand = this.parseUnary(lang)
       return { type: 'UpdateExpression', operator: '--', prefix: true, operand }
     }
@@ -2333,123 +2426,14 @@ class EtherParserPHP extends EtherParserBase {
     }
   }
 
-  tryParseMultiWordCall(firstName, lang) {
-    const words = [firstName]
-    let lookAhead = 0
-    
-    while (true) {
-      const nextToken = this.peek(lookAhead)
-      if (!nextToken) break
-      
-      if (nextToken.type === TokenType.LPAREN) {
-        if (words.length > 1) {
-          for (let i = 0; i < lookAhead; i++) {
-            this.advance()
-          }
-          this.advance()
-          
-          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 {
-              const arg = this.parseExpression(lang)
-              args.push(arg)
-            }
-            this.match(TokenType.COMMA)
-            this.skipNewlines()
-          }
-          this.match(TokenType.RPAREN)
-          
-          const funcName = words.join(' ')
-          return { 
-            type: 'CallExpression', 
-            callee: { type: 'Identifier', name: funcName }, 
-            arguments: args 
-          }
-        }
-        break
-      }
-      
-      if (nextToken.type === TokenType.IDENTIFIER) {
-        words.push(this.safeStr(nextToken.value))
-        lookAhead++
-      } else {
-        break
-      }
-    }
-    
-    return null
-  }
-
-  tryParseMultiWordCallFromStart(lang) {
-    const words = []
-    let lookAhead = 0
-    
-    while (true) {
-      const token = this.peek(lookAhead)
-      if (!token) break
-      
-      if (token.type === TokenType.LPAREN) {
-        if (words.length >= 2) {
-          for (let i = 0; i < lookAhead; i++) {
-            this.advance()
-          }
-          this.advance()
-          
-          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 {
-              const arg = this.parseExpression(lang)
-              args.push(arg)
-            }
-            this.match(TokenType.COMMA)
-            this.skipNewlines()
-          }
-          this.match(TokenType.RPAREN)
-          
-          const funcName = words.join(' ')
-          return { 
-            type: 'CallExpression', 
-            callee: { type: 'Identifier', name: funcName }, 
-            arguments: args 
-          }
-        }
-        break
-      }
-      
-      if (token.type === TokenType.IDENTIFIER) {
-        words.push(this.safeStr(token.value))
-        lookAhead++
-      } else {
-        break
-      }
-    }
-    
-    return null
-  }
-
   parsePostfix(lang) {
     let expr = this.parseCall(lang)
 
-    const current = this.current()
-    if (current && current.type === TokenType.PLUS && current.value === '++') {
-      this.advance()
+    if (this.match(TokenType.DOUBLE_PLUS) || this.matchValue('++')) {
       return { type: 'UpdateExpression', operator: '++', prefix: false, operand: expr }
     }
 
-    if (current && current.type === TokenType.MINUS && current.value === '--') {
-      this.advance()
+    if (this.match(TokenType.DOUBLE_MINUS) || this.matchValue('--')) {
       return { type: 'UpdateExpression', operator: '--', prefix: false, operand: expr }
     }
 
@@ -2459,13 +2443,6 @@ class EtherParserPHP extends EtherParserBase {
   parseCall(lang) {
     let expr = this.parsePrimary(lang)
 
-    if (expr && expr.type === 'Identifier') {
-      const multiWordResult = this.tryParseMultiWordCall(expr.name, lang)
-      if (multiWordResult) {
-        return multiWordResult
-      }
-    }
-
     while (true) {
       if (this.match(TokenType.LPAREN)) {
         const args = []
@@ -2548,11 +2525,11 @@ class EtherParserPHP extends EtherParserBase {
 
     if (token.type === TokenType.STRING) {
       this.advance()
-      let value = this.safeStr(token.value)
+      let value = token.value
       if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
         value = value.slice(1, -1)
       }
-      const isDouble = value.startsWith('"') || this.safeStr(token.value).startsWith('"')
+      const isDouble = token.value.startsWith('"')
       return { type: 'StringLiteral', value, doubleQuoted: isDouble }
     }
 
@@ -2562,7 +2539,7 @@ class EtherParserPHP extends EtherParserBase {
     }
 
     if (token.type === TokenType.IDENTIFIER) {
-      const value = this.safeStr(token.value)
+      const value = token.value
       const valueLower = this.normalizeAccents(value.toLowerCase())
 
       if (valueLower === 'vrai' || valueLower === 'true') {
@@ -2612,7 +2589,7 @@ class EtherParserPHP extends EtherParserBase {
         return this.parseMatchExpression(lang)
       }
 
-      if (value.startsWith('$')) {
+      if (typeof value === 'string' && value.startsWith('$')) {
         this.advance()
         return { type: 'Variable', name: value.substring(1) }
       }
@@ -2623,7 +2600,7 @@ class EtherParserPHP extends EtherParserBase {
 
     if (token.type === TokenType.VARIABLE) {
       this.advance()
-      let name = this.safeStr(token.value)
+      let name = String(token.value)
       if (name.startsWith('$')) name = name.substring(1)
       return { type: 'Variable', name }
     }