ether-code 0.8.7 → 0.8.8

package/package.json

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

package/parsers/ether-parser-base.js

@@ -1,5 +1,5 @@
 const fs = require('fs')
-const { EtherLexer, Token, TokenType } = require('../lexer/ether-lexer')
+const { EtherLexer, Token, TokenType } = require('./ether-lexer')
 
 class EtherParserBase {
   constructor(options = {}) {
@@ -17,16 +17,16 @@ class EtherParserBase {
   initCompoundTerms() {
     this.compoundOperators = {
       'strictement egal': '===',
-      'strictement égal': '===',
+      'strictement égal': '===',
       'strictement different': '!==',
-      'strictement différent': '!==',
+      'strictement différent': '!==',
       'superieur ou egal': '>=',
-      'supérieur ou égal': '>=',
+      'supérieur ou égal': '>=',
       'inferieur ou egal': '<=',
-      'inférieur ou égal': '<=',
+      'inférieur ou égal': '<=',
       'coalescence nulle': '??',
       'chainage optionnel': '?.',
-      'chaînage optionnel': '?.'
+      'chaînage optionnel': '?.'
     }
     
     this.compoundKeywords = {
@@ -36,7 +36,7 @@ class EtherParserBase {
       'fonction asynchrone': 'async function',
       'fonction async': 'async function',
       'fonction generatrice': 'function*',
-      'fonction génératrice': 'function*',
+      'fonction génératrice': 'function*',
       'variable globale': 'var'
     }
   }
@@ -105,7 +105,7 @@ class EtherParserBase {
   expect(type) {
     const token = this.current()
     if (!token || token.type !== type) {
-      throw new Error(`Attendu ${type}, reçu ${token ? token.type : 'EOF'}`)
+      throw new Error(`Attendu ${type}, reçu ${token ? token.type : 'EOF'}`)
     }
     return this.advance()
   }
@@ -358,4 +358,4 @@ class EtherParserBase {
   }
 }
 
-module.exports = { EtherParserBase, TokenType }
+module.exports = { EtherParserBase, TokenType }

package/parsers/ether-parser-php.js

@@ -278,6 +278,16 @@ class EtherParserPHP extends EtherParserBase {
 
     const value = token.value != null ? this.normalizeAccents(String(token.value).toLowerCase()) : ''
 
+    if (token.type === TokenType.IDENTIFIER) {
+      const multiWordCall = this.tryParseMultiWordCallFromStart(lang)
+      if (multiWordCall) {
+        return {
+          type: 'ExpressionStatement',
+          expression: multiWordCall
+        }
+      }
+    }
+
     if (this.isDeclare(value)) {
       return this.parseDeclare(lang)
     }
@@ -375,7 +385,7 @@ class EtherParserPHP extends EtherParserBase {
   }
 
   isNamespace(value) {
-    if (value === 'namespace') return true
+    if (value === 'namespace' || value === 'espace de noms') return true
     if (value === 'espace') {
       const next1 = this.peek(1)
       const next2 = this.peek(2)
@@ -526,7 +536,7 @@ class EtherParserPHP extends EtherParserBase {
     const first = this.advance()
     const firstVal = this.normalizeAccents(String(first.value).toLowerCase())
     
-    if (firstVal === 'espace') {
+    if (firstVal === 'espace' && firstVal !== 'espace de noms') {
       this.advance()
       this.advance()
     }
@@ -639,6 +649,7 @@ class EtherParserPHP extends EtherParserBase {
       } while (this.match(TokenType.COMMA))
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const body = this.parseClassBody(lang)
 
@@ -768,6 +779,7 @@ class EtherParserPHP extends EtherParserBase {
       }
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     
     let body = null
@@ -791,6 +803,11 @@ 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()
@@ -932,6 +949,7 @@ class EtherParserPHP extends EtherParserBase {
       } while (this.match(TokenType.COMMA))
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const body = this.parseClassBody(lang)
 
@@ -950,6 +968,7 @@ class EtherParserPHP extends EtherParserBase {
     const name = nameToken ? nameToken.value : 'AnonymousTrait'
     if (nameToken) this.advance()
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const body = this.parseClassBody(lang)
 
@@ -981,6 +1000,7 @@ class EtherParserPHP extends EtherParserBase {
       } while (this.match(TokenType.COMMA))
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const cases = this.parseEnumBody(lang)
 
@@ -1336,7 +1356,10 @@ class EtherParserPHP extends EtherParserBase {
     this.skipNewlines()
     
     const elseVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
-    if (elseVal === 'sinon') {
+    if (elseVal === 'sinon si' || elseVal === 'elseif') {
+      alternate = this.parseConditional(lang)
+      alternate.type = 'IfStatement'
+    } else if (elseVal === 'sinon') {
       this.advance()
       
       const nextVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
@@ -1410,7 +1433,6 @@ class EtherParserPHP extends EtherParserBase {
 
     if (value === 'foreach' || value === 'pour chaque') {
       this.advance()
-      if (value === 'pour chaque') this.advance()
       return this.parseForeach(lang)
     }
 
@@ -1629,9 +1651,10 @@ class EtherParserPHP extends EtherParserBase {
       discriminant = this.parseExpression(lang)
       this.match(TokenType.RPAREN)
     } else {
-      discriminant = this.parseExpression(lang)
+      discriminant = this.parseConditionUntilColon(lang)
     }
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const cases = this.parseSwitchBody(lang)
 
@@ -1645,7 +1668,7 @@ class EtherParserPHP extends EtherParserBase {
   parseSwitchBody(lang) {
     const cases = []
     
-    this.match(TokenType.LBRACE)
+    const hasBrace = this.match(TokenType.LBRACE)
     this.skipNewlines()
     this.match(TokenType.INDENT)
 
@@ -1666,13 +1689,20 @@ class EtherParserPHP extends EtherParserBase {
         const test = this.parseExpression(lang)
         this.match(TokenType.COLON)
         this.skipNewlines()
+        this.match(TokenType.INDENT)
         
         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) {
+          this.skipNewlines()
+          const cur = this.current()
+          if (!cur) break
+          
+          const nextVal = this.normalizeAccents(String(cur.value).toLowerCase())
+          if (['cas', 'case', 'defaut', 'default'].includes(nextVal)) {
+            break
+          }
+          if (cur.type === TokenType.RBRACE || cur.type === TokenType.DEDENT) {
+            this.advance()
             break
           }
           const stmt = this.parseStatement(lang)
@@ -1689,10 +1719,15 @@ class EtherParserPHP extends EtherParserBase {
         this.advance()
         this.match(TokenType.COLON)
         this.skipNewlines()
+        this.match(TokenType.INDENT)
         
         const consequent = []
         while (!this.isAtEnd()) {
-          if (this.current().type === TokenType.RBRACE || this.current().type === TokenType.DEDENT) {
+          this.skipNewlines()
+          const cur = this.current()
+          if (!cur) break
+          if (cur.type === TokenType.RBRACE || cur.type === TokenType.DEDENT) {
+            this.advance()
             break
           }
           const stmt = this.parseStatement(lang)
@@ -1778,6 +1813,7 @@ class EtherParserPHP extends EtherParserBase {
   parseTryStatement(lang) {
     this.advance()
 
+    this.match(TokenType.COLON)
     this.skipNewlines()
     const tryBlock = this.parseBlock(lang)
 
@@ -1816,8 +1852,26 @@ class EtherParserPHP extends EtherParserBase {
           }
         }
         this.match(TokenType.RPAREN)
+      } else {
+        const typeToken = this.current()
+        if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
+          types.push(this.safeStr(typeToken.value))
+          this.advance()
+        }
+        
+        const asVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
+        if (asVal === 'comme' || asVal === 'as') {
+          this.advance()
+          const paramToken = this.current()
+          if (paramToken && paramToken.type === TokenType.IDENTIFIER) {
+            param = this.safeStr(paramToken.value)
+            if (param.startsWith('$')) param = param.substring(1)
+            this.advance()
+          }
+        }
       }
 
+      this.match(TokenType.COLON)
       this.skipNewlines()
       const catchBlock = this.parseBlock(lang)
 
@@ -1835,6 +1889,7 @@ class EtherParserPHP extends EtherParserBase {
     const finallyVal = this.current() ? this.normalizeAccents(String(this.current().value).toLowerCase()) : ''
     if (finallyVal === 'finalement' || finallyVal === 'finally') {
       this.advance()
+      this.match(TokenType.COLON)
       this.skipNewlines()
       finallyBlock = this.parseBlock(lang)
     }
@@ -2278,6 +2333,112 @@ 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)
 
@@ -2298,6 +2459,13 @@ 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 = []