Pass tokens to BranchNode.

Author: vlad-shatskyi

src/Autocompletion.ts

@@ -78,8 +78,6 @@ export const {getSuggestions} = new class {
     // };
 
     getSuggestions = async (job: Job) => {
-        const leaf = leafNodeAt(job.prompt.value.length, parse(scan(job.prompt.value)));
-        debugger;
-        return leaf.suggestions;
+        return leafNodeAt(job.prompt.value.length, job.prompt.ast).suggestions;
     };
 };

src/Prompt.ts

@@ -2,6 +2,7 @@ import * as events from "events";
 import {Job} from "./Job";
 import {scan, Token} from "./shell/Scanner";
 import {expandAliases} from "./shell/CommandExpander";
+import {ASTNode, parse} from "./shell/Parser2";
 
 export class Prompt extends events.EventEmitter {
     private _value = "";
@@ -19,13 +20,17 @@ export class Prompt extends events.EventEmitter {
     setValue(value: string): void {
         this._value = value;
         this._tokens = scan(this.value);
-        this._expanded = expandAliases(this._tokens, this.job.session.aliases);
+        this._expanded = []; // expandAliases(this._tokens, this.job.session.aliases);
     }
 
     get tokens(): Token[] {
         return this._tokens;
     }
 
+    get ast(): ASTNode {
+        return parse(this.tokens);
+    }
+
     get expanded(): Token[] {
         return this._expanded;
     }

src/shell/Parser2.ts

@@ -1,8 +1,8 @@
-import {Token} from "./Scanner";
+import {Token, Empty} from "./Scanner";
 import * as _ from "lodash";
 import {Suggestion} from "../plugins/autocompletion_providers/Suggestions";
 
-abstract class ASTNode {
+export abstract class ASTNode {
     abstract get fullStart(): number;
     abstract get fullEnd(): number;
 }
@@ -17,7 +17,7 @@ abstract class LeafNode extends ASTNode {
     }
 
     get fullEnd(): number {
-        return this.fullStart + this.token.raw.length - 1;
+        return this.fullStart + this.token.raw.length;
     }
 
     get value(): string {
@@ -28,12 +28,10 @@ abstract class LeafNode extends ASTNode {
 }
 
 abstract class BranchNode extends ASTNode {
-    readonly children: ASTNode[];
+    abstract get children(): ASTNode[];
 
-    constructor(children: ASTNode[]) {
+    constructor(protected childTokens: Token[]) {
         super();
-
-        this.children = children;
     }
 
     get fullStart(): number {
@@ -46,21 +44,27 @@ abstract class BranchNode extends ASTNode {
 }
 
 class CompleteCommand extends BranchNode {
+    get children(): ASTNode[] {
+        return [new Command(this.childTokens)];
+    }
 }
 
 class Command extends BranchNode {
-    readonly commandWord: CommandWord;
-    readonly argumentList: ArgumentList;
-
-    constructor(tokens: Token[]) {
-        const commandWord = new CommandWord(tokens[0]);
+    get children(): ASTNode[] {
+        const children: ASTNode[] = [this.commandWord];
+        if (this.childTokens.length > 1) {
+            children.push(this.argumentList);
+        }
 
-        const argumentList = tokens.length === 1 ? new EmptyArgumentList(() => this) : new ArgumentList(tokens.slice(1).map(token => new Argument(token, this)));
+        return children;
+    }
 
-        super([commandWord, argumentList]);
+    get commandWord(): CommandWord {
+        return new CommandWord(this.childTokens[0]);
+    }
 
-        this.commandWord = commandWord;
-        this.argumentList = argumentList;
+    get argumentList(): ArgumentList | undefined {
+        return new ArgumentList(this.childTokens.slice(1), this);
     }
 }
 
@@ -71,6 +75,13 @@ class CommandWord extends LeafNode {
 }
 
 class ArgumentList extends BranchNode {
+    constructor(childTokens: Token[], private command: Command) {
+        super (childTokens);
+    }
+
+    get children(): ASTNode[] {
+        return this.childTokens.map(token => new Argument(token, this.command));
+    }
 }
 
 class Argument extends LeafNode {
@@ -90,10 +101,22 @@ class Argument extends LeafNode {
     }
 }
 
-export function parse(tokens: Token[]): CompleteCommand {
-    return new CompleteCommand([
-        new Command(tokens),
-    ]);
+class EmptyNode extends LeafNode {
+    constructor() {
+        super(new Empty());
+    }
+
+    get suggestions(): Suggestion[] {
+        return [];
+    }
+}
+
+export function parse(tokens: Token[]): ASTNode {
+    if (tokens.length === 0) {
+        return new EmptyNode();
+    }
+
+    return new CompleteCommand(tokens);
 }
 
 export function leafNodeAt(position: number, node: ASTNode): LeafNode {

src/shell/Scanner.ts

@@ -19,6 +19,20 @@ export abstract class Token {
     }
 }
 
+export class Empty extends Token {
+    constructor() {
+        super("", 0);
+    }
+
+    get value() {
+        return "";
+    }
+
+    get escapedValue() {
+        return <EscapedShellWord>this.raw.trim();
+    }
+}
+
 export class Word extends Token {
     get value() {
         return this.raw.trim().replace(/\\\s/, " ");

test/shell/parser_spec.ts

@@ -19,7 +19,7 @@ async function parse(parser: Parser, input: string) {
     ));
 }
 
-describe.only("parser", () => {
+describe("parser", () => {
     describe("sequence", () => {
         describe("git commit", () => {
             const git = string("git");