chore: new named-factory methods for lexer construction

Author: nos1dot618

include/lbd/frontend/lexer.h

@@ -7,29 +7,25 @@
 #include <vector>
 
 namespace frontend {
-    struct FromFile {
-    };
-
-    struct FromRepl {
-    };
-
     struct Lexer {
-        // TODO: Make factory instead of these constructors.
-        Lexer(const std::string &filepath, FromFile, global::Options options_ = {});
+        static Lexer fromFile(const std::string &filepath, global::Options options = {});
+
+        static Lexer fromRepl(const std::string &source, global::Options options = {});
 
-        Lexer(std::string str, FromRepl, global::Options options_ = {});
+        // TODO: Add fromStdin
 
         token::Token nextToken();
 
-        // TODO: Find a better name for this.
-        std::vector<token::Token> lexAll();
+        std::vector<token::Token> lex();
 
     private:
+        explicit Lexer(std::string filepath, std::string source, global::Options options = {});
+
         std::string source;
         size_t position = 0;
         size_t row = 1;
         size_t col = 1;
-        std::string filepath;
+        const std::string filepath;
 
         [[nodiscard]] char peek() const;
 

src/frontend/lexer.cpp

@@ -33,19 +33,23 @@ namespace frontend {
         return {row, col, filepath};
     }
 
-    Lexer::Lexer(const std::string &filepath, FromFile, global::Options options_) : filepath(filepath) {
-        std::ifstream ifs(filepath);
-        optionsValue = options_;
-        if (!ifs) {
+    Lexer Lexer::fromFile(const std::string &filepath, const global::Options options) {
+        std::ifstream fileStream(filepath);
+        if (!fileStream) {
             optionsValue.logger.error({}, "IO error: could not open file ", filepath);
         }
-        std::ostringstream ss;
-        ss << ifs.rdbuf();
-        source = ss.str();
+        std::ostringstream stringStream;
+        stringStream << fileStream.rdbuf();
+        return Lexer(filepath, stringStream.str(), options);
     }
 
-    Lexer::Lexer(std::string str, FromRepl, const global::Options options_) : source(std::move(str)) {
-        optionsValue = options_;
+    Lexer Lexer::fromRepl(const std::string &source, const global::Options options) {
+        return Lexer("", source, options);
+    }
+
+    Lexer::Lexer(std::string filepath, std::string source, const global::Options options) : source(std::move(source)),
+        filepath(std::move(filepath)) {
+        optionsValue = options;
     }
 
     token::Token Lexer::nextToken() {
@@ -152,7 +156,7 @@ namespace frontend {
         optionsValue.logger.error(currentLocation, "syntax error: unexpected character ", currentCharacter);
     }
 
-    std::vector<token::Token> Lexer::lexAll() {
+    std::vector<token::Token> Lexer::lex() {
         std::vector<token::Token> tokens;
         while (true) {
             token::Token token = nextToken();

src/frontend/parser.cpp

@@ -152,8 +152,8 @@ namespace frontend {
             return;
         }
         loadedFiles.insert(absolutePath);
-        auto lexerValue = Lexer(filepath, FromFile{}, optionsValue);
-        const auto tokens = lexerValue.lexAll();
+        auto lexerValue = Lexer::fromFile(filepath, optionsValue);
+        const auto tokens = lexerValue.lex();
         if (optionsValue.debug) {
             for (const auto &token: tokens) {
                 optionsValue.logger.debug(token);

src/main.cpp

@@ -20,8 +20,8 @@ int main(const int argc, char **argv) {
         repl::loop(debug);
     } else {
         // Lex
-        auto lexerValue = frontend::Lexer(*filepath, frontend::FromFile{});
-        const std::vector<frontend::token::Token> tokens = lexerValue.lexAll();
+        auto lexerValue = frontend::Lexer::fromFile(*filepath);
+        const std::vector<frontend::token::Token> tokens = lexerValue.lex();
         if (debug) {
             for (const frontend::token::Token &token: tokens) {
                 std::cout << token << std::endl;

src/repl.cpp

@@ -25,8 +25,8 @@ namespace repl {
             subOptions.logger.error({}, "IO error: filepath ", filepath, " does not exist");
         }
 
-        frontend::Lexer lexer(filepath, frontend::FromFile{}, subOptions);
-        const auto tokens = lexer.lexAll();
+        frontend::Lexer lexer = frontend::Lexer::fromFile(filepath, subOptions);
+        const auto tokens = lexer.lex();
         if (subOptions.debug) {
             for (const auto &token: tokens) {
                 subOptions.logger.debug(token);
@@ -204,8 +204,8 @@ namespace repl {
                 buffer.clear();
 
                 // Lex
-                frontend::Lexer lexerValue(line, frontend::FromRepl{}, optionsValue);
-                const std::vector<frontend::token::Token> tokens = lexerValue.lexAll();
+                frontend::Lexer lexerValue = frontend::Lexer::fromRepl(line, optionsValue);
+                const std::vector<frontend::token::Token> tokens = lexerValue.lex();
                 if (optionsValue.debug) {
                     for (const auto &tok: tokens) {
                         optionsValue.logger.debug(tok);