goldstein 1.6.0 → 2.2.0

package/ChangeLog

@@ -1,3 +1,22 @@
+2022.06.27, v2.2.0
+
+feature:
+- goldstein: add support of throw expressions
+
+
+2022.06.25, v2.1.0
+
+feature:
+- goldstein: integrate 'should'
+- add should keyword (#5)
+
+
+2022.06.22, v2.0.0
+
+feature:
+- goldstein: keyword: safe -> try
+
+
 2022.06.22, v1.6.0
 
 feature:

package/README.md

@@ -9,11 +9,13 @@
 [CoverageURL]: https://coveralls.io/github/coderaiser/goldstein?branch=master
 [CoverageIMGURL]: https://coveralls.io/repos/coderaiser/goldstein/badge.svg?branch=master&service=github
 
+![image](https://user-images.githubusercontent.com/1573141/175353192-9867d3ba-beaf-46d5-adbc-e2eb736bfef1.png)
+
 > *"You haven't a real appreciation of Newspeak, Winston," he said almost sadly. "Even when you write it you're still thinking in Oldspeak. I've read some of those pieces that you write in The Times occasionally. They're good enough, but they're translations. In your heart you'd prefer to stick to Oldspeak, with all its vagueness and its useless shades of meaning. You don't grasp the beauty of the destruction of words. Do you know that Newspeak is the only language in the world whose vocabulary gets smaller every year?"*
 >
 > *(c) “1984”, George Orwell*
 
-JavaScript with no limits.
+JavaScript with no limits 🤫.
 
 Language ruled by the users, [create an issue](https://github.com/coderaiser/goldstein/issues/new/choose) with ideas of a new language construction and what is look like in JavaScript, and most likely we implement it :).
 
@@ -49,7 +51,7 @@ import {compile} from 'goldstein';
 
 compile(`
     fn hello() {
-        guard (text !== "world") else {
+        guard text !== "world" else {
             return ""
         }
         
@@ -77,7 +79,7 @@ Here is the list.
 
 You can use `fn` to declare a `function`:
 
-```gs
+```rust
 fn hello() {
     return 'world';
 }
@@ -95,7 +97,7 @@ function hello() {
 
 Applies not to `IfCondition`:
 
-```gs
+```swift
 fn hello() {
     guard text !== "world" else {
         return ""
@@ -117,12 +119,14 @@ function hello() {
 }
 ```
 
-### `safe`
+### `try`
+
+`try` can be used as an expression.
 
 Applies [`tryCatch`](https://github.com/coderaiser/try-catch):
 
 ```gs
-const [error, result] = safe hello(1, 2, 3);
+const [error, result] = try hello(1, 2, 3);
 ```
 
 Is the same as:
@@ -135,7 +139,7 @@ const [error, result] = tryCatch(1, 2, 3);
 and
 
 ```gs
-const [error, result] = safe await hello(1, 2, 3);
+const [error, result] = try await hello(1, 2, 3);
 ```
 
 Is the same as:
@@ -145,16 +149,41 @@ import tryToCatch from 'try-catch';
 const [error, result] = await tryToCatch(1, 2, 3);
 ```
 
+### `should`
+
+`should` can be used as an expression (just like [`try`](https://github.com/coderaiser/goldstein/edit/master/README.md#try)).
+This keyword is useful if you want to prevent a function call (also async) to throw an error because you don't need to have any result and the real execution is just optional (so runs if supported).
+
+```gs
+should hello()
+```
+
+Is the same as:
+
+```gs
+try hello();
+```
+
+> ☝️ *Warning: this feature can be helpful but also dangerous especially if you're debugging your application. In fact, this is made to be used as an optional function call (ex. should load content, but not necessary and knowing this feature is optional), if you call a function in this way while debugging, no error will be printed and the application will continue run as nothing happened.*
+
 ### `if`
 
 You can omit parens. But you must use braces in this case.
 
-```gs
+```rust
 if a > 3 {
     hello();
 }
 ```
 
+### `throw expression`
+
+You can use [throw as expression](https://github.com/tc39/proposal-throw-expressions), just like that:
+
+```js
+const a = () => throw 'hello';
+```
+
 ## How to contribute?
 
 Clone the registry, create a new keyword with a prefix `keyword-`, then create directory `fixture` and put there two files with extensions `.js` and `.gs`. Half way done 🥳!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "1.6.0",
+  "version": "2.2.0",
   "type": "module",
   "commitType": "colon",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",

package/packages/goldstein/index.js

@@ -4,13 +4,19 @@ import putout, {
 import {extendParser} from '../parser/index.js';
 import keywordFn from '../keyword-fn/index.js';
 import keywordGuard from '../keyword-guard/index.js';
-import keywordSafe from '../keyword-safe/index.js';
+import keywordTry from '../keyword-try/index.js';
+import keywordShould from '../keyword-should/index.js';
+import keywordThrow from '../keyword-throw/index.js';
+import stringInterpolation from '../string-interpolation/index.js';
 
 export const compile = (source) => {
     const {parse} = extendParser([
         keywordFn,
         keywordGuard,
-        keywordSafe,
+        keywordTry,
+        keywordShould,
+        keywordThrow,
+        stringInterpolation,
     ]);
     
     const ast = parse(source);

package/packages/keyword-if/index.js

@@ -8,6 +8,7 @@ export default function fn(Parser) {
             this.next();
             
             const isParenL = this.eat(tt.parenL);
+            
             node.test = this.parseExpression();
             const isParenR = this.eat(tt.parenR);
             

package/packages/keyword-should/index.js

@@ -0,0 +1,91 @@
+import {types} from 'putout';
+import {
+    addKeyword,
+    TokenType,
+    tokTypes as tt,
+} from '../operator/index.js';
+
+const {
+    isCallExpression,
+    isAwaitExpression,
+} = types;
+
+export default function newSpeak(Parser) {
+    const {keywordTypes} = Parser.acorn;
+    keywordTypes.should = new TokenType('should', {
+        keyword: 'should',
+    });
+    
+    return class extends Parser {
+        parse() {
+            this.keywords = addKeyword('should', this.keywords);
+            return super.parse();
+        }
+        parseStatement(context, topLevel, exports) {
+            if (this.type === keywordTypes.should) {
+                return this.parseShould();
+            }
+            
+            return super.parseStatement(context, topLevel, exports);
+        }
+        
+        parseShould() {
+            this.next();
+            
+            const node = super.startNode();
+            
+            if (this.type === tt.braceL)
+                return this.raise(this.start, `After 'should' only 'await' and 'function call' can come, brakets are not supported`);
+            
+            const expression = this.parseExpression();
+            
+            if (isCallExpression(expression))
+                node.expression = {
+                    type: 'TryStatement',
+                    block: {
+                        type: 'BlockStatement',
+                        body: [{
+                            type: 'ExpressionStatement',
+                            expression: {
+                                type: 'CallExpression',
+                                callee: expression.callee,
+                                arguments: expression.arguments.slice(),
+                            },
+                        }],
+                    },
+                    handler: {
+                        type: 'CatchClause',
+                        body: {
+                            type: 'BlockStatement',
+                            body: [],
+                        },
+                    },
+                };
+            
+            else if (isAwaitExpression(expression))
+                node.expression = {
+                    type: 'TryStatement',
+                    block: {
+                        type: 'BlockStatement',
+                        body: [{
+                            type: 'ExpressionStatement',
+                            expression,
+                        }],
+                    },
+                    handler: {
+                        type: 'CatchClause',
+                        body: {
+                            type: 'BlockStatement',
+                            body: [],
+                        },
+                    },
+                };
+            
+            else
+                this.raise(this.start, `After 'should' only 'await' and 'function call' can come`);
+            
+            return super.finishNode(node, 'ExpressionStatement');
+        }
+    };
+}
+

package/packages/keyword-throw/index.js

@@ -0,0 +1,30 @@
+const {assign} = Object;
+
+export default function keywordThrow(Parser) {
+    const {keywordTypes} = Parser.acorn;
+    
+    return class extends Parser {
+        parseExprAtom(refDestructuringErrors, forInit) {
+            if (this.type === keywordTypes.throw) {
+                return this.parseThrowExpression();
+            }
+            
+            return super.parseExprAtom(refDestructuringErrors, forInit);
+        }
+        
+        parseThrowExpression() {
+            this.next();
+            
+            const node = super.startNode();
+            const expression = this.parseExpression();
+            
+            assign(node, {
+                operator: 'throw',
+                argument: expression,
+            });
+            
+            return super.finishNode(node, 'UnaryExpression');
+        }
+    };
+}
+

package/packages/{keyword-safe → keyword-try}/index.js

@@ -1,7 +1,9 @@
 import {types} from 'putout';
 import {
-    addKeyword,
-    TokenType,
+    BIND_LEXICAL,
+    BIND_SIMPLE_CATCH,
+    SCOPE_SIMPLE_CATCH,
+    tokTypes as tt,
 } from '../operator/index.js';
 
 const {
@@ -9,39 +11,25 @@ const {
     isAwaitExpression,
 } = types;
 
-// why not 'try'?
-// because acorn internals should be copied, and added tests.
-// there is no such thing as this.previous(), only this.next() 🤷‍
-
 export default function newSpeak(Parser) {
     const {keywordTypes} = Parser.acorn;
-    keywordTypes.safe = new TokenType('safe', {
-        keyword: 'safe',
-    });
     
     return class extends Parser {
-        parse() {
-            this.keywords = addKeyword('safe', this.keywords);
-            
-            return super.parse();
-        }
-        parseStatement(context, topLevel, exports) {
-            if (this.type === keywordTypes.safe)
-                return this.parseSafe();
-            
-            return super.parseStatement(context, topLevel, exports);
-        }
         parseExprAtom(refDestructuringErrors, forInit) {
-            if (this.type === keywordTypes.safe)
-                return this.parseSafe();
+            if (this.type === keywordTypes.try)
+                return this.parseTryStatement();
             
             return super.parseExprAtom(refDestructuringErrors, forInit);
         }
         
-        parseSafe() {
+        parseTryStatement() {
             this.next();
             
             const node = super.startNode();
+            
+            if (this.type === tt.braceL)
+                return this.parseUglyTry(node);
+            
             const expression = this.parseExpression();
             
             if (isCallExpression(expression))
@@ -74,10 +62,42 @@ export default function newSpeak(Parser) {
                 };
             
             else
-                this.raise(this.start, `After 'safe' only 'await' and 'function call' can come`);
+                this.raise(this.start, `After 'try' only '{', 'await' and 'function call' can come`);
             
             return super.finishNode(node, 'ExpressionStatement');
         }
+        parseUglyTry(node) {
+            node.block = this.parseBlock();
+            node.handler = null;
+            
+            if (this.type === tt._catch) {
+                const clause = this.startNode();
+                this.next();
+                
+                if (this.eat(tt.parenL)) {
+                    clause.param = this.parseBindingAtom();
+                    const simple = clause.param.type === 'Identifier';
+                    
+                    this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
+                    this.checkLValPattern(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
+                    this.expect(tt.parenR);
+                } else {
+                    clause.param = null;
+                    this.enterScope(0);
+                }
+                
+                clause.body = this.parseBlock(false);
+                this.exitScope();
+                node.handler = this.finishNode(clause, 'CatchClause');
+            }
+            
+            node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
+            
+            if (!node.handler && !node.finalizer)
+                this.raise(node.start, 'Missing catch or finally clause');
+            
+            return this.finishNode(node, 'TryStatement');
+        }
     };
 }
 

package/packages/operator/index.js

@@ -1,4 +1,5 @@
 export * from 'acorn';
+export * from './scopeflags.js';
 
 export function addKeyword(keyword, keywords) {
     const str = keywords

package/packages/operator/scopeflags.js

@@ -0,0 +1,21 @@
+// Each scope gets a bitset that may contain these flags
+export const
+    SCOPE_TOP = 1,
+    SCOPE_FUNCTION = 2,
+    SCOPE_ASYNC = 4,
+    SCOPE_GENERATOR = 8,
+    SCOPE_ARROW = 16,
+    SCOPE_SIMPLE_CATCH = 32,
+    SCOPE_SUPER = 64,
+    SCOPE_DIRECT_SUPER = 128,
+    SCOPE_CLASS_STATIC_BLOCK = 256,
+    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK;
+
+// Used in checkLVal* and declareName to determine the type of a binding
+export const
+    BIND_NONE = 0, // Not a binding
+    BIND_VAR = 1, // Var-style binding
+    BIND_LEXICAL = 2, // Let- or const-style binding
+    BIND_FUNCTION = 3, // Function declaration
+    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding
+    BIND_OUTSIDE = 5; // Special case for function names as bound inside the function

package/packages/string-interpolation/index.js

@@ -0,0 +1,65 @@
+import {template} from 'putout';
+const {assign} = Object;
+
+export default function stringInterpolation(Parser) {
+    return class extends Parser {
+        parseLiteral(value) {
+            const chars = value.split('');
+            
+            let literalOpened = false;
+            let parenthesis = 0;
+            const out = [];
+            let isTemplateLiteral = false;
+            
+            for (let [index, char] of chars.entries()) {
+                if (char === '(') {
+                    // keep count of parenthesis
+                    parenthesis++;
+                    
+                    // check if previous token was "/" (only if literal is not opened yet)
+                    const prev = index - 1;
+                    
+                    if (chars[prev] === '/' && !literalOpened) {
+                        // set previous char to "$"
+                        out[prev] = '$';
+                        // set current char to "{"
+                        char = '{';
+                        
+                        // set literalOpened to true
+                        literalOpened = true;
+                        // match TemplateLiteral instead of StringLiteral
+                        isTemplateLiteral = true;
+                    }
+                } else if (char === ')') {
+                    parenthesis--;
+                    
+                    if (parenthesis === 0 && literalOpened) {
+                        char = '}';
+                        
+                        // reset literalOpened to false
+                        literalOpened = false;
+                    }
+                }
+                
+                out.push(char);
+            }
+            
+            if (isTemplateLiteral) {
+                const node = this.startNode();
+                this.next();
+                
+                const {quasis, expressions} = template.ast('`' + out.join('') + '`');
+                
+                assign(node, {
+                    quasis,
+                    expressions,
+                });
+                
+                return this.finishNode(node, 'TemplateLiteral');
+            }
+            
+            return super.parseLiteral(out.join(''));
+        }
+    };
+}
+