Refactor

src/ast.ts

 export type Primary = _Number | Identifier | Backtick | Alias;
 export type Statement = SelectStatement;
 export type Expr = Primary | Binary;
+export type SelectArgument = Expr;
 export type FromTarget = Identifier | Backtick | Alias;

src/parser.ts

 
   private select(): AST.Statement | Error {
     this.eat(TokenKind.SELECT);
-    const args = this.args();
+    const args = this.selectArguments();
     if (isError(args)) {
       return args;
     }
     });
   }
 
-  private args(): AST.Expr[] | Error {
+  private selectArguments(): AST.SelectArgument[] | Error {
     const args = [];
 
     while (true) {
   }
 
   private fromTarget(): AST.FromTarget | Error {
-    const token = this.currentToken();
-    switch (token.kind) {
-      case TokenKind.BACKTICK:
-        const backtick = this.backtick();
-        if (isError(backtick)) {
-          return backtick;
-        }
-
-        if (this.match(TokenKind.AS)) {
-          return this.fromTargetAlias(backtick);
-        }
-
-        return backtick;
-      case TokenKind.IDENTIFIER:
-        const identifier = this.identifier();
-        if (isError(identifier)) {
-          return identifier;
-        }
-
-        if (this.match(TokenKind.AS)) {
-          return this.fromTargetAlias(identifier);
-        }
-
-        return identifier;
+    const primary = this.backtickOrIdentifier();
+    if (!this.match(TokenKind.AS) || isError(primary)) {
+      return primary;
     }
 
-    return new Error(`Unexpected token: ${token.repr()}`, token.line);
-  }
-
-  private fromTargetAlias(obj: AST.Identifier | AST.Backtick): AST.Alias | Error {
     this.eat(TokenKind.AS);
 
     const token = this.currentToken();
       return alias;
     }
 
-    return new AST.Alias(obj, alias);
+    return new AST.Alias(primary, alias);
   }
 
   private where(): AST.Expr | Error {
     return primary;
   }
 
+  private backtickOrIdentifier(): AST.Backtick | AST.Identifier | Error {
+    const token = this.currentToken();
+    switch (token.kind) {
+      case TokenKind.BACKTICK:
+        return this.backtick();
+      case TokenKind.IDENTIFIER:
+        return this.identifier();
+      default:
+        return new Error(`Unexpected token: ${token.repr()}`, token.line);
+    }
+  }
+
   private backtick(): AST.Backtick | Error {
     this.eat(TokenKind.BACKTICK);
     const identifier = this.identifier();