goldstein 1.4.0 → 2.0.0

package/ChangeLog

@@ -1,3 +1,21 @@
+2022.06.22, v2.0.0
+
+feature:
+- goldstein: keyword: safe -> try
+
+
+2022.06.22, v1.6.0
+
+feature:
+- goldstein: guard keyword: add ability to omit parens
+
+
+2022.06.22, v1.5.0
+
+feature:
+- goldstein: keyword if: add ability to omit parens
+
+
 2022.06.22, v1.4.0
 
 feature:

package/README.md

@@ -77,7 +77,7 @@ Here is the list.
 
 You can use `fn` to declare a `function`:
 
-```gs
+```rust
 fn hello() {
     return 'world';
 }
@@ -95,9 +95,9 @@ function hello() {
 
 Applies not to `IfCondition`:
 
-```gs
+```swift
 fn hello() {
-    guard (text !== "world") else {
+    guard text !== "world" else {
         return ""
     }
 
@@ -117,12 +117,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 +137,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,6 +147,16 @@ import tryToCatch from 'try-catch';
 const [error, result] = await tryToCatch(1, 2, 3);
 ```
 
+### `if`
+
+You can omit parens. But you must use braces in this case.
+
+```rust
+if a > 3 {
+    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.4.0",
+  "version": "2.0.0",
   "type": "module",
   "commitType": "colon",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",

package/packages/goldstein/index.js

@@ -4,13 +4,13 @@ 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';
 
 export const compile = (source) => {
     const {parse} = extendParser([
         keywordFn,
         keywordGuard,
-        keywordSafe,
+        keywordTry,
     ]);
     
     const ast = parse(source);

package/packages/keyword-guard/index.js

@@ -33,7 +33,7 @@ export default function newSpeak(Parser) {
             } = tokTypes;
             
             const node = super.startNode();
-            super.expect(parenL);
+            const isParenL = super.eat(parenL);
             
             node.test = {
                 type: 'UnaryExpression',
@@ -42,7 +42,11 @@ export default function newSpeak(Parser) {
                 argument: super.parseExpression(),
             };
             
-            super.expect(parenR);
+            const isParenR = super.eat(parenR);
+            
+            if (isParenL !== isParenR)
+                this.raise(this.start, `Use both parens ('(', ')') or none`);
+            
             super.expect(_else);
             
             node.consequent = this.parseStatement();

package/packages/keyword-if/index.js

@@ -0,0 +1,27 @@
+import {
+    tokTypes as tt,
+} from '../operator/index.js';
+
+export default function fn(Parser) {
+    return class extends Parser {
+        parseIfStatement(node) {
+            this.next();
+            
+            const isParenL = this.eat(tt.parenL);
+            node.test = this.parseExpression();
+            const isParenR = this.eat(tt.parenR);
+            
+            if (!isParenL && !isParenR && this.type !== tt.braceL)
+                this.raise(this.start, `Use braces ('{', '}') when omit parens ('(', ')')`);
+            
+            if (isParenL !== isParenR)
+                this.raise(this.start, `Use both parens ('(', ')') or none`);
+            
+            node.consequent = this.parseStatement('if');
+            node.alternate = this.eat(tt._else) ? this.parseStatement('if') : null;
+            
+            return this.finishNode(node, 'IfStatement');
+        }
+    };
+}
+

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,24 @@ 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 +61,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