ether-code 0.9.4 → 0.9.6

package/cli/ether.js

@@ -6,7 +6,7 @@ const http = require('http')
 const { EtherCompiler } = require('./compiler')
 const { Watcher } = require('./watcher')
 
-const VERSION = '0.9.4'
+const VERSION = '0.9.6'
 
 const COLORS = {
   reset: '\x1b[0m',

package/generators/php-generator.js

@@ -134,7 +134,6 @@ class PHPGenerator {
       'formater nombre': 'number_format',
       'date': 'date',
       'temps': 'time',
-      'maintenant': 'time',
       'creer date': 'mktime',
       'date vers temps': 'strtotime',
       'formater date': 'date_format',
@@ -305,23 +304,60 @@ class PHPGenerator {
     return this.keywordMap[normalized] || word
   }
 
+  translateMethodName(word) {
+    if (!word) return word
+    const normalized = this.normalizeAccents(word)
+    const magicMethods = {
+      'constructeur': '__construct',
+      'destructeur': '__destruct',
+      'obtenir': '__get',
+      'definir': '__set',
+      'appeler': '__call',
+      'vers chaine': '__toString',
+      'invoquer': '__invoke',
+      'cloner': '__clone',
+      'serialiser': '__serialize',
+      'deserialiser': '__unserialize',
+      'deboguer': '__debugInfo'
+    }
+    return magicMethods[normalized] || word
+  }
+
   extractTypeName(typeNode) {
     if (!typeNode) return ''
-    if (typeof typeNode === 'string') return this.translateKeyword(typeNode)
+    if (typeof typeNode === 'string') {
+      const translated = this.translateKeyword(typeNode)
+      return this.prefixGlobalClass(translated)
+    }
     if (typeNode.type === 'TypeHint') {
-      const types = (typeNode.types || []).map(t => this.translateKeyword(t))
+      const types = (typeNode.types || []).map(t => {
+        const translated = this.translateKeyword(t)
+        return this.prefixGlobalClass(translated)
+      })
       const result = types.join('|')
       return typeNode.nullable ? '?' + result : result
     }
-    if (typeNode.name) return this.translateKeyword(typeNode.name)
-    if (typeNode.type === 'Identifier') return this.translateKeyword(typeNode.name || typeNode.value || '')
-    if (typeNode.value) return this.translateKeyword(typeNode.value)
+    if (typeNode.name) {
+      const translated = this.translateKeyword(typeNode.name)
+      return this.prefixGlobalClass(translated)
+    }
+    if (typeNode.type === 'Identifier') {
+      const translated = this.translateKeyword(typeNode.name || typeNode.value || '')
+      return this.prefixGlobalClass(translated)
+    }
+    if (typeNode.value) {
+      const translated = this.translateKeyword(typeNode.value)
+      return this.prefixGlobalClass(translated)
+    }
     return ''
   }
 
   generate(ast) {
     this.output = ''
     this.indent = 0
+    this.closureVariables = new Set()
+    
+    this.collectClosureVariables(ast)
 
     if (ast.phpTag !== false) {
       this.output = '<?php\n'
@@ -346,6 +382,32 @@ class PHPGenerator {
     return this.output.trim()
   }
 
+  collectClosureVariables(ast) {
+    const nodes = Array.isArray(ast) ? ast : (ast?.body || [ast])
+    
+    for (const node of nodes) {
+      if (!node) continue
+      
+      if (node.type === 'VariableDeclaration') {
+        const init = node.init || node.value
+        if (init && (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression' || init.type === 'ClosureExpression')) {
+          const name = node.name || node.id?.name
+          if (name) this.closureVariables.add(name)
+        }
+      }
+      
+      if (node.body) {
+        this.collectClosureVariables(node.body)
+      }
+      if (node.consequent) {
+        this.collectClosureVariables(Array.isArray(node.consequent) ? node.consequent : [node.consequent])
+      }
+      if (node.alternate) {
+        this.collectClosureVariables(Array.isArray(node.alternate) ? node.alternate : [node.alternate])
+      }
+    }
+  }
+
   generateNode(node) {
     if (!node) return ''
 
@@ -381,6 +443,8 @@ class PHPGenerator {
         return this.generateForStatement(node)
       case 'ForEachStatement':
         return this.generateForEachStatement(node)
+      case 'ForeachStatement':
+        return this.generateForEachStatement(node)
       case 'WhileStatement':
         return this.generateWhileStatement(node)
       case 'DoWhileStatement':
@@ -615,7 +679,7 @@ class PHPGenerator {
   generateClassMember(node) {
     if (!node) return
 
-    if (node.type === 'UseTraitStatement') {
+    if (node.type === 'UseTraitStatement' || node.type === 'TraitUse') {
       this.writeLine(`use ${node.traits.join(', ')};`)
       return
     }
@@ -634,7 +698,7 @@ class PHPGenerator {
       this.writeLine(`${visibility} ${isStatic}${isReadonly}${typeHint}${name}${value};`)
     } else if (node.type === 'Method' || node.kind === 'method' || node.type === 'MethodDeclaration') {
       const name = node.name || node.key?.name || ''
-      const translatedName = this.translateKeyword(name)
+      const translatedName = this.translateMethodName(name)
       const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
       let returnType = ''
       
@@ -688,7 +752,7 @@ class PHPGenerator {
 
     const visibility = 'public'
     const name = node.name || node.key?.name || ''
-    const translatedName = this.translateKeyword(name)
+    const translatedName = this.translateMethodName(name)
     const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
     let returnType = ''
     
@@ -871,21 +935,26 @@ class PHPGenerator {
     this.generateBody(node.block)
     this.indent--
 
-    if (node.handler) {
-      const exceptionType = node.handler.exceptionType || node.handler.type || 'Exception'
-      const param = node.handler.param 
-        ? this.generateVariable(node.handler.param) 
+    const catches = node.catches || (node.handler ? [node.handler] : [])
+    for (const catchClause of catches) {
+      const types = catchClause.types || []
+      let exceptionType = types.length > 0 
+        ? types.map(t => this.prefixGlobalClass(t)).join('|') 
+        : this.prefixGlobalClass(catchClause.exceptionType || catchClause.type || 'Exception')
+      const param = catchClause.param 
+        ? this.generateVariable(catchClause.param) 
         : '$e'
       this.writeLine(`} catch (${exceptionType} ${param}) {`)
       this.indent++
-      this.generateBody(node.handler.body)
+      this.generateBody(catchClause.body)
       this.indent--
     }
 
-    if (node.finalizer) {
+    const finallyBlock = node.finally || node.finalizer
+    if (finallyBlock) {
       this.writeLine('} finally {')
       this.indent++
-      this.generateBody(node.finalizer)
+      this.generateBody(finallyBlock)
       this.indent--
     }
 
@@ -893,6 +962,31 @@ class PHPGenerator {
     return ''
   }
 
+  prefixGlobalClass(name) {
+    const phpGlobalClasses = [
+      'Exception', 'Error', 'TypeError', 'ValueError', 'ArgumentCountError',
+      'ArithmeticError', 'DivisionByZeroError', 'ParseError', 'AssertionError',
+      'CompileError', 'UnhandledMatchError', 'FiberError',
+      'ErrorException', 'BadFunctionCallException', 'BadMethodCallException',
+      'DomainException', 'InvalidArgumentException', 'LengthException',
+      'LogicException', 'OutOfBoundsException', 'OutOfRangeException',
+      'OverflowException', 'RangeException', 'RuntimeException',
+      'UnderflowException', 'UnexpectedValueException',
+      'PDOException', 'JsonException', 'IntlException',
+      'Generator', 'Iterator', 'IteratorAggregate', 'Traversable',
+      'ArrayAccess', 'Countable', 'Serializable', 'Stringable',
+      'DateTime', 'DateTimeImmutable', 'DateTimeInterface', 'DateInterval', 'DatePeriod',
+      'PDO', 'PDOStatement', 'Closure', 'stdClass', 'WeakReference', 'WeakMap',
+      'SplFileInfo', 'SplFileObject', 'SplTempFileObject',
+      'ArrayObject', 'ArrayIterator', 'RecursiveArrayIterator',
+      'Fiber', 'ReflectionClass', 'ReflectionMethod', 'ReflectionProperty'
+    ]
+    if (phpGlobalClasses.includes(name) && !name.startsWith('\\')) {
+      return '\\' + name
+    }
+    return name
+  }
+
   generateReturnStatement(node) {
     if (node.argument) {
       const arg = this.generateNode(node.argument)
@@ -932,19 +1026,82 @@ class PHPGenerator {
 
   generateCallExpression(node) {
     let callee
+    let originalName = ''
     
     if (typeof node.callee === 'string') {
-      callee = this.translateFunction(node.callee)
+      originalName = node.callee
+      if (this.closureVariables && this.closureVariables.has(node.callee)) {
+        callee = '$' + node.callee
+      } else {
+        callee = this.translateFunction(node.callee)
+      }
     } else if (node.callee.type === 'Identifier') {
-      callee = this.translateFunction(node.callee.name)
+      originalName = node.callee.name
+      if (this.closureVariables && this.closureVariables.has(node.callee.name)) {
+        callee = '$' + node.callee.name
+      } else {
+        callee = this.translateFunction(node.callee.name)
+      }
+    } else if (node.callee.type === 'Variable') {
+      callee = this.generateVariable(node.callee)
     } else if (node.callee.type === 'MemberExpression' || node.callee.type === 'StaticMemberExpression') {
       callee = this.generateNode(node.callee)
     } else {
       callee = this.generateNode(node.callee)
     }
     
-    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
-    return `${callee}(${args})`
+    let args = (node.arguments || []).map(a => this.generateNode(a))
+    
+    args = this.reorderArguments(callee, args, originalName)
+    args = this.addDefaultArguments(callee, args)
+    
+    return `${callee}(${args.join(', ')})`
+  }
+
+  reorderArguments(func, args, originalName) {
+    const normalized = this.normalizeAccents(originalName)
+    
+    if ((func === 'str_replace' || normalized === 'remplacer') && args.length === 3) {
+      return [args[1], args[2], args[0]]
+    }
+    
+    if ((func === 'array_map' || normalized === 'mapper' || normalized === 'mapper tableau' || normalized === 'transformer') && args.length === 2) {
+      return [args[1], args[0]]
+    }
+    
+    return args
+  }
+
+  addDefaultArguments(func, args) {
+    if (func === 'password_hash' && args.length === 1) {
+      return [...args, 'PASSWORD_DEFAULT']
+    }
+    
+    return args
+  }
+
+  isNativeFunction(name) {
+    const natives = [
+      'echo', 'print', 'var_dump', 'print_r', 'die', 'exit',
+      'strlen', 'substr', 'strpos', 'str_replace', 'strtoupper', 'strtolower',
+      'trim', 'ltrim', 'rtrim', 'explode', 'implode', 'sprintf', 'printf',
+      'count', 'array_push', 'array_pop', 'array_shift', 'array_unshift',
+      'array_merge', 'array_filter', 'array_map', 'array_reduce', 'array_keys',
+      'array_values', 'array_sum', 'array_unique', 'array_reverse', 'sort',
+      'in_array', 'array_key_exists', 'array_search',
+      'is_array', 'is_string', 'is_int', 'is_float', 'is_bool', 'is_null',
+      'is_numeric', 'is_object', 'is_callable', 'isset', 'empty', 'gettype',
+      'intval', 'floatval', 'strval', 'boolval', 'settype',
+      'abs', 'ceil', 'floor', 'round', 'sqrt', 'pow', 'rand', 'max', 'min', 'pi',
+      'date', 'time', 'strtotime', 'mktime',
+      'file_exists', 'file_get_contents', 'file_put_contents', 'fopen', 'fclose', 'fread', 'fwrite',
+      'json_encode', 'json_decode', 'preg_match', 'preg_match_all', 'preg_replace',
+      'header', 'session_start', 'session_destroy', 'password_hash', 'password_verify',
+      'include', 'include_once', 'require', 'require_once',
+      'class_exists', 'function_exists', 'method_exists', 'defined', 'define', 'constant',
+      'new', 'throw'
+    ]
+    return natives.includes(name)
   }
 
   generateMemberExpression(node) {
@@ -952,9 +1109,9 @@ class PHPGenerator {
     let property
     
     if (typeof node.property === 'string') {
-      property = node.property
+      property = this.translateMemberProperty(node.property)
     } else if (node.property.type === 'Identifier') {
-      property = this.translateFunction(node.property.name)
+      property = this.translateMemberProperty(node.property.name)
     } else {
       property = this.generateNode(node.property)
     }
@@ -967,6 +1124,26 @@ class PHPGenerator {
     return `${object}${operator}${property}`
   }
 
+  translateMemberProperty(name) {
+    const translations = {
+      'valeur': 'value',
+      'nom': 'name',
+      'message': 'message',
+      'code': 'code',
+      'fichier': 'file',
+      'ligne': 'line',
+      'precedent': 'previous',
+      'trace': 'trace',
+      'formater': 'format',
+      'ajouter': 'add',
+      'modifier': 'modify',
+      'obtenir': 'get',
+      'definir': 'set'
+    }
+    const normalized = this.normalizeAccents(name)
+    return translations[normalized] || name
+  }
+
   generateStaticMemberExpression(node) {
     const cls = node.class?.name || this.generateNode(node.class)
     let member = node.member?.name || this.generateNode(node.member)
@@ -1060,12 +1237,6 @@ class PHPGenerator {
     const name = node.name || node
     if (typeof name !== 'string') return '$var'
     
-    const normalized = this.normalizeAccents(name)
-    
-    if (this.functionMap[normalized]) {
-      return this.functionMap[normalized]
-    }
-    
     const translated = this.translateKeyword(name)
     
     if (translated.startsWith('$')) return translated
@@ -1073,11 +1244,11 @@ class PHPGenerator {
       return translated
     }
     if (/^[A-Z]/.test(translated)) return translated
-    if (translated === name && !name.startsWith('$')) {
+    if (!name.startsWith('$')) {
       return '$' + name
     }
     
-    return translated.startsWith('$') ? translated : '$' + translated
+    return name
   }
 
   generateVariable(node) {
@@ -1110,9 +1281,9 @@ class PHPGenerator {
   generateNewExpression(node) {
     let callee
     if (typeof node.callee === 'string') {
-      callee = node.callee
+      callee = this.prefixGlobalClass(node.callee)
     } else if (node.callee.type === 'Identifier') {
-      callee = node.callee.name
+      callee = this.prefixGlobalClass(node.callee.name)
     } else {
       callee = this.generateNode(node.callee)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ether-code",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Ether - Le langage intentionnel",
   "main": "cli/compiler.js",
   "bin": {

package/parsers/ether-parser-php.js

@@ -159,7 +159,6 @@ class EtherParserPHP extends EtherParserBase {
       'json decoder': 'json_decode',
       'date': 'date',
       'temps': 'time',
-      'maintenant': 'time',
       'demarrer session': 'session_start',
       'detruire session': 'session_destroy',
       'definir cookie': 'setcookie',