#787: improved code generation strategy

Author: petermasking

packages/analysis/src/static/Coder.ts

@@ -1,7 +1,8 @@
 
 import Token from './models/Token';
 import { TokenType } from './definitions/TokenType';
-import { Keyword } from './definitions/Keyword';
+
+const NO_TOKEN = new Token(TokenType.NONE, '', -1, 0);
 
 export default class Coder
 {
@@ -27,62 +28,46 @@ export default class Coder
     generate(): string
     {
         let code = '';
-        let previous: Token = new Token(TokenType.NOTHING, '', 0, 0);
-
-        for (const current of this.#tokens)
+        
+        for (let index = 0; index < this.#tokens.length; index++)
         {
-            const prefix = this.#needsSpacingBefore(current, previous) ? ' ' : '';
-            const postfix = this.#needsSpacingAfter(current) ? ' ' : '';
+            const previous = this.#tokens[index - 1] ?? NO_TOKEN;
+            const current = this.#tokens[index];
+            const next = this.#tokens[index + 1] ?? NO_TOKEN;
+            
+            const prefix = this.#needsSpacingBefore(previous, current) ? ' ' : '';
+            const postfix = this.#needsSpacingAfter(current, next) ? ' ' : '';
 
             code += `${prefix}${current.value}${postfix}`;
-
-            previous = current;
         }
 
         return code;
     }
 
-    #needsSpacingBefore(current: Token, previous: Token): boolean
+    #needsSpacingBefore(previous: Token, current: Token): boolean
     {
-        if (current.isType(TokenType.KEYWORD) && this.#isInfixKeyword(current))
+        if (current.isType(TokenType.KEYWORD) && this.#isTextType(previous))
         {
             return true;
         }
-        else if (previous.isType(TokenType.OPERATOR) && current.isType(TokenType.OPERATOR))
+        else if (current.isType(TokenType.OPERATOR) && previous.isType(TokenType.OPERATOR))
         {
             return true;
         }
 
         return false;
     }
 
-    #needsSpacingAfter(current: Token): boolean
-    {
-        return current.isType(TokenType.KEYWORD) && this.#isPrefixKeyword(current);
-    }
-
-    #isPrefixKeyword(token: Token): boolean
+    #needsSpacingAfter(current: Token, next: Token): boolean
     {
-        return this.#isInfixKeyword(token)
-            || token.hasValue(Keyword.VAR)
-            || token.hasValue(Keyword.LET)
-            || token.hasValue(Keyword.CONST)
-            || token.hasValue(Keyword.FUNCTION)
-            || token.hasValue(Keyword.CLASS)
-            || token.hasValue(Keyword.USING)
-            || token.hasValue(Keyword.RETURN)
-            || token.hasValue(Keyword.ASYNC)
-            || token.hasValue(Keyword.AWAIT)
-            || token.hasValue(Keyword.YIELD)
-            || token.hasValue(Keyword.NEW)
-            || token.hasValue(Keyword.THROW);
+        return current.isType(TokenType.KEYWORD) && (next.isType(TokenType.KEYWORD) || this.#isTextType(next));
     }
 
-    #isInfixKeyword(token: Token): boolean
+    #isTextType(token: Token)
     {
-        return token.hasValue(Keyword.OF)
-            || token.hasValue(Keyword.IN)
-            || token.hasValue(Keyword.AS)
-            || token.hasValue(Keyword.FROM);
+        return token.isType(TokenType.IDENTIFIER)
+            || token.isType(TokenType.BOOLEAN)
+            || token.isType(TokenType.NOTHING)
+            || token.isType(TokenType.NUMBER);
     }
 }

packages/analysis/src/static/definitions/TokenType.ts

@@ -15,7 +15,8 @@ const TokenType =
     INDICATOR: 'indicator',
     REGEX: 'regex',
     SCOPE: 'scope',
-    WHITESPACE: 'whitespace'
+    WHITESPACE: 'whitespace',
+    NONE: 'none'
 };
 
 export { TokenType };

packages/analysis/test/static/Parser.spec.ts

@@ -52,7 +52,7 @@ describe('Parser', () =>
         {
             const expression = parser.parseStatement(VALUES.IF_ELSE);
             expect(expression).toBeInstanceOf(ESExpression);
-            expect(expression.toString(false)).toEqual('if(true){return "value1";}else{return "value2";}');
+            expect(expression.toString(false)).toEqual('if(true){return"value1";}else{return"value2";}');
         });
 
         it('should parse an try...catch...finally expression', () =>
@@ -557,7 +557,7 @@ describe('Parser', () =>
             expect(variable.binding).toBeInstanceOf(ESIdentifierBinding);
             expect(variable.type).toEqual('const');
             expect(variable.initializer).toBeInstanceOf(ESExpression);
-            expect(variable.initializer?.toString(false)).toEqual(' as ');
+            expect(variable.initializer?.toString(false)).toEqual('as');
         });
     });
 
@@ -928,7 +928,7 @@ describe('Parser', () =>
 
             expect(funktion.identifier).toEqual('name');
             expect(funktion.isAsync).toBeFalsy();
-            expect(funktion.body.toString()).toEqual("{return 'value';}");
+            expect(funktion.body.toString()).toEqual("{return'value';}");
 
             const parameters = funktion.parameters;
             expect(parameters).toHaveLength(0);
@@ -940,7 +940,7 @@ describe('Parser', () =>
 
             expect(funktion.identifier).toEqual('name');
             expect(funktion.isAsync).toBeFalsy();
-            expect(funktion.body.toString()).toEqual("{if(true){return 'value';}}");
+            expect(funktion.body.toString()).toEqual("{if(true){return'value';}}");
 
             const parameters = funktion.parameters;
             expect(parameters).toHaveLength(0);

packages/analysis/test/static/fixtures/modules.fixture.ts

@@ -82,7 +82,7 @@ export {Person};
 class Person{#name;#age;constructor(name,age) {this.#name=name;this.#age=age;}}
 const peter=new Person(name,42);
 async function async(){}
-const a=async ;
+const a=async;
 const b=async ()=>{};
 const as=12;
 export {as as hi};