Added namespaces to most classes, general cleanup

src/Binder/BoundExpressions/BoundExpression.hpp

@@ -10,322 +10,330 @@
 
 using namespace std;
 
-enum class BoundExpressionKind{
-    Bad,
+namespace Porygon::Binder {
+    enum class BoundExpressionKind {
+        Bad,
 
-    LiteralInteger,
-    LiteralFloat,
-    LiteralString,
-    LiteralBool,
-    Variable,
+        LiteralInteger,
+        LiteralFloat,
+        LiteralString,
+        LiteralBool,
+        Variable,
 
-    Unary,
-    Binary,
-    FunctionCall,
-    Index,
-    PeriodIndex,
-    NumericalTable,
-    Table,
-};
-
-class BoundExpression{
-    const unsigned int _start;
-    const unsigned int _length;
-    const shared_ptr<ScriptType> _type;
-public:
-    BoundExpression(unsigned int start, unsigned int length, shared_ptr<ScriptType>  type)
-        : _start(start),
-          _length(length),
-          _type(std::move(type))
-    {
-    }
-
-    virtual ~BoundExpression() = default;
-
-    virtual const BoundExpressionKind GetKind() const = 0;
-    virtual const std::shared_ptr<ScriptType>& GetType() const{
-        return _type;
+        Unary,
+        Binary,
+        FunctionCall,
+        Index,
+        PeriodIndex,
+        NumericalTable,
+        Table,
     };
 
-    const unsigned int GetStartPosition() const{
-        return _start;
-    }
-    const unsigned int GetLength() const{
-        return _length;
-    }
-    const unsigned int GetEndPosition() const{
-        return _start + _length - 1;
-    }
-};
-
-class BoundBadExpression : public BoundExpression{
-public:
-    BoundBadExpression(unsigned int start, unsigned int length) : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Error)){}
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::Bad;
-    }
-};
-
-class BoundLiteralIntegerExpression : public BoundExpression{
-    const long _value;
-public:
-    BoundLiteralIntegerExpression(long value, unsigned int start, unsigned int length)
-        : BoundExpression(start, length, make_shared<NumericScriptType>(true, false)),
-          _value(value)
-    {
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::LiteralInteger;
-    }
-
-    const long GetValue() const{
-        return _value;
-    }
-};
-
-class BoundLiteralFloatExpression : public BoundExpression{
-    const double _value;
-public:
-    BoundLiteralFloatExpression(double value, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, make_shared<NumericScriptType>(true, true)),
-              _value(value)
-    {
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::LiteralFloat;
-    }
-
-    const double GetValue() const{
-        return _value;
-    }
-};
-
-class BoundLiteralStringExpression : public BoundExpression{
-    const u16string _value;
-public:
-    BoundLiteralStringExpression(const u16string& value, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, make_shared<StringScriptType>(true, HashedString::ConstHash(value.c_str()))),
-              _value(value)
-    {
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::LiteralString;
-    }
-
-    const u16string GetValue() const{
-        return _value;
-    }
-};
-
-class BoundLiteralBoolExpression : public BoundExpression{
-    const bool _value;
-public:
-    BoundLiteralBoolExpression(bool value, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)),
-              _value(value)
-    {
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::LiteralBool;
-    }
-
-    const bool GetValue() const{
-        return _value;
-    }
-};
-
-class BoundVariableExpression : public BoundExpression{
-    const BoundVariableKey* _key;
-public:
-    BoundVariableExpression(BoundVariableKey* key, shared_ptr<ScriptType> type, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, std::move(type)),
-              _key(key)
-    {
-    }
-
-    ~BoundVariableExpression() override{
-        delete _key;
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::Variable;
-    }
-
-    const BoundVariableKey* GetKey() const{
-        return _key;
-    }
-};
-
-class BoundBinaryExpression : public BoundExpression {
-    const BoundExpression* _left;
-    const BoundExpression* _right;
-    const BoundBinaryOperation _operation;
-public:
-    BoundBinaryExpression(BoundExpression* left, BoundExpression* right, BoundBinaryOperation op, shared_ptr<ScriptType> result,
-                          unsigned int start, unsigned int length)
-    : BoundExpression(start, length, std::move(result)),
-      _left(left),
-      _right(right),
-      _operation(op)
-    {
-    }
-
-    ~BoundBinaryExpression() final{
-        delete _left;
-        delete _right;
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::Binary;
-    }
-
-    const BoundExpression* GetLeft() const{
-        return _left;
-    }
-
-    const BoundExpression* GetRight() const{
-        return _right;
-    }
-
-    const BoundBinaryOperation GetOperation() const{
-        return _operation;
-    }
-};
-
-class BoundUnaryExpression : public BoundExpression {
-    const BoundExpression* _operand;
-    const BoundUnaryOperation  _operation;
-public:
-    BoundUnaryExpression(BoundExpression* operand, BoundUnaryOperation op, shared_ptr<ScriptType> result, unsigned int start, unsigned int length)
-        : BoundExpression(start, length, std::move(result)),
-          _operand(operand),
-          _operation(op)
-    {
-    }
-
-    ~BoundUnaryExpression() final{
-        delete _operand;
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::Unary;
-    }
-
-    const BoundExpression* GetOperand() const{
-        return _operand;
-    }
-
-    const BoundUnaryOperation GetOperation() const{
-        return _operation;
-    }
-};
-
-class BoundFunctionCallExpression : public BoundExpression {
-    const BoundExpression* _functionExpression;
-    const vector<BoundExpression*> _parameters;
-public:
-    BoundFunctionCallExpression(BoundExpression *functionExpression, vector<BoundExpression *> parameters, shared_ptr<ScriptType> result,
-            unsigned int start, unsigned int length)
-            : BoundExpression(start, length, std::move(result)), _functionExpression(functionExpression), _parameters(std::move(parameters)) {}
-
-    ~BoundFunctionCallExpression() final{
-        delete _functionExpression;
-        for (auto p : _parameters){
-            delete p;
+    class BoundExpression {
+        const unsigned int _start;
+        const unsigned int _length;
+        const shared_ptr<ScriptType> _type;
+    public:
+        BoundExpression(unsigned int start, unsigned int length, shared_ptr<ScriptType> type)
+                : _start(start),
+                  _length(length),
+                  _type(std::move(type)) {
         }
-    }
 
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::FunctionCall;
-    }
+        virtual ~BoundExpression() = default;
 
-    const BoundExpression* GetFunctionExpression() const{
-        return _functionExpression;
-    }
+        virtual const BoundExpressionKind GetKind() const = 0;
 
-    const vector<BoundExpression*>* GetParameters() const{
-        return &_parameters;
-    }
-};
+        virtual const std::shared_ptr<ScriptType> &GetType() const {
+            return _type;
+        };
 
-class BoundIndexExpression : public BoundExpression {
-    const BoundExpression* _indexableExpression;
-    const BoundExpression* _indexExpression;
-public:
-    BoundIndexExpression(BoundExpression* indexableExpression, BoundExpression* indexExpression, shared_ptr<ScriptType> result,
-                                unsigned int start, unsigned int length)
-            : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression), _indexExpression(indexExpression) {}
-
-    ~BoundIndexExpression() final{
-        delete _indexableExpression;
-        delete _indexExpression;
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::Index;
-    }
-
-    const BoundExpression* GetIndexableExpression() const{
-        return _indexableExpression;
-    }
-
-    const BoundExpression* GetIndexExpression() const{
-        return _indexExpression;
-    }
-};
-
-class BoundPeriodIndexExpression : public BoundExpression {
-    const BoundExpression* _indexableExpression;
-    const HashedString _index;
-public:
-    BoundPeriodIndexExpression(BoundExpression* indexableExpression, HashedString index, shared_ptr<ScriptType> result,
-                         unsigned int start, unsigned int length)
-            : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression), _index(index) {}
-
-    ~BoundPeriodIndexExpression() final{
-        delete _indexableExpression;
-    }
-
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::PeriodIndex;
-    }
-
-    const BoundExpression* GetIndexableExpression() const{
-        return _indexableExpression;
-    }
-
-    const HashedString GetIndex() const{
-        return _index;
-    }
-};
-
-class BoundNumericalTableExpression : public BoundExpression{
-    const vector<const BoundExpression*> _expressions;
-public:
-    BoundNumericalTableExpression(vector<const BoundExpression*> expressions, shared_ptr<ScriptType> type, unsigned int start, unsigned int length)
-        : BoundExpression(start, length, std::move(type)),
-          _expressions(std::move(expressions))
-        {}
-
-    ~BoundNumericalTableExpression() final{
-        for (auto e: _expressions){
-            delete e;
+        const unsigned int GetStartPosition() const {
+            return _start;
         }
-    }
 
-    const BoundExpressionKind GetKind() const final{
-        return BoundExpressionKind ::NumericalTable;
-    }
+        const unsigned int GetLength() const {
+            return _length;
+        }
 
-    const vector<const BoundExpression*>* GetExpressions() const{
-        return &_expressions;
-    }
-};
+        const unsigned int GetEndPosition() const {
+            return _start + _length - 1;
+        }
+    };
 
+    class BoundBadExpression : public BoundExpression {
+    public:
+        BoundBadExpression(unsigned int start, unsigned int length) : BoundExpression(start, length,
+                                                                                      make_shared<ScriptType>(
+                                                                                              TypeClass::Error)) {}
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::Bad;
+        }
+    };
+
+    class BoundLiteralIntegerExpression : public BoundExpression {
+        const long _value;
+    public:
+        BoundLiteralIntegerExpression(long value, unsigned int start, unsigned int length)
+                : BoundExpression(start, length, make_shared<NumericScriptType>(true, false)),
+                  _value(value) {
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::LiteralInteger;
+        }
+
+        const long GetValue() const {
+            return _value;
+        }
+    };
+
+    class BoundLiteralFloatExpression : public BoundExpression {
+        const double _value;
+    public:
+        BoundLiteralFloatExpression(double value, unsigned int start, unsigned int length)
+                : BoundExpression(start, length, make_shared<NumericScriptType>(true, true)),
+                  _value(value) {
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::LiteralFloat;
+        }
+
+        const double GetValue() const {
+            return _value;
+        }
+    };
+
+    class BoundLiteralStringExpression : public BoundExpression {
+        const u16string _value;
+    public:
+        BoundLiteralStringExpression(const u16string &value, unsigned int start, unsigned int length)
+                : BoundExpression(start, length,
+                                  make_shared<StringScriptType>(true, Utilities::HashedString::ConstHash(value.c_str()))),
+                  _value(value) {
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::LiteralString;
+        }
+
+        const u16string GetValue() const {
+            return _value;
+        }
+    };
+
+    class BoundLiteralBoolExpression : public BoundExpression {
+        const bool _value;
+    public:
+        BoundLiteralBoolExpression(bool value, unsigned int start, unsigned int length)
+                : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)),
+                  _value(value) {
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::LiteralBool;
+        }
+
+        const bool GetValue() const {
+            return _value;
+        }
+    };
+
+    class BoundVariableExpression : public BoundExpression {
+        const BoundVariableKey *_key;
+    public:
+        BoundVariableExpression(BoundVariableKey *key, shared_ptr<ScriptType> type, unsigned int start,
+                                unsigned int length)
+                : BoundExpression(start, length, std::move(type)),
+                  _key(key) {
+        }
+
+        ~BoundVariableExpression() override {
+            delete _key;
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::Variable;
+        }
+
+        const BoundVariableKey *GetKey() const {
+            return _key;
+        }
+    };
+
+    class BoundBinaryExpression : public BoundExpression {
+        const BoundExpression *_left;
+        const BoundExpression *_right;
+        const BoundBinaryOperation _operation;
+    public:
+        BoundBinaryExpression(BoundExpression *left, BoundExpression *right, BoundBinaryOperation op,
+                              shared_ptr<ScriptType> result,
+                              unsigned int start, unsigned int length)
+                : BoundExpression(start, length, std::move(result)),
+                  _left(left),
+                  _right(right),
+                  _operation(op) {
+        }
+
+        ~BoundBinaryExpression() final {
+            delete _left;
+            delete _right;
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::Binary;
+        }
+
+        const BoundExpression *GetLeft() const {
+            return _left;
+        }
+
+        const BoundExpression *GetRight() const {
+            return _right;
+        }
+
+        const BoundBinaryOperation GetOperation() const {
+            return _operation;
+        }
+    };
+
+    class BoundUnaryExpression : public BoundExpression {
+        const BoundExpression *_operand;
+        const BoundUnaryOperation _operation;
+    public:
+        BoundUnaryExpression(BoundExpression *operand, BoundUnaryOperation op, shared_ptr<ScriptType> result,
+                             unsigned int start, unsigned int length)
+                : BoundExpression(start, length, std::move(result)),
+                  _operand(operand),
+                  _operation(op) {
+        }
+
+        ~BoundUnaryExpression() final {
+            delete _operand;
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::Unary;
+        }
+
+        const BoundExpression *GetOperand() const {
+            return _operand;
+        }
+
+        const BoundUnaryOperation GetOperation() const {
+            return _operation;
+        }
+    };
+
+    class BoundFunctionCallExpression : public BoundExpression {
+        const BoundExpression *_functionExpression;
+        const vector<BoundExpression *> _parameters;
+    public:
+        BoundFunctionCallExpression(BoundExpression *functionExpression, vector<BoundExpression *> parameters,
+                                    shared_ptr<ScriptType> result,
+                                    unsigned int start, unsigned int length)
+                : BoundExpression(start, length, std::move(result)), _functionExpression(functionExpression),
+                  _parameters(std::move(parameters)) {}
+
+        ~BoundFunctionCallExpression() final {
+            delete _functionExpression;
+            for (auto p : _parameters) {
+                delete p;
+            }
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::FunctionCall;
+        }
+
+        const BoundExpression *GetFunctionExpression() const {
+            return _functionExpression;
+        }
+
+        const vector<BoundExpression *> *GetParameters() const {
+            return &_parameters;
+        }
+    };
+
+    class BoundIndexExpression : public BoundExpression {
+        const BoundExpression *_indexableExpression;
+        const BoundExpression *_indexExpression;
+    public:
+        BoundIndexExpression(BoundExpression *indexableExpression, BoundExpression *indexExpression,
+                             shared_ptr<ScriptType> result,
+                             unsigned int start, unsigned int length)
+                : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression),
+                  _indexExpression(indexExpression) {}
+
+        ~BoundIndexExpression() final {
+            delete _indexableExpression;
+            delete _indexExpression;
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::Index;
+        }
+
+        const BoundExpression *GetIndexableExpression() const {
+            return _indexableExpression;
+        }
+
+        const BoundExpression *GetIndexExpression() const {
+            return _indexExpression;
+        }
+    };
+
+    class BoundPeriodIndexExpression : public BoundExpression {
+        const BoundExpression *_indexableExpression;
+        const Utilities::HashedString _index;
+    public:
+        BoundPeriodIndexExpression(BoundExpression *indexableExpression, Utilities::HashedString index,
+                                   shared_ptr<ScriptType> result,
+                                   unsigned int start, unsigned int length)
+                : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression),
+                  _index(index) {}
+
+        ~BoundPeriodIndexExpression() final {
+            delete _indexableExpression;
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::PeriodIndex;
+        }
+
+        const BoundExpression *GetIndexableExpression() const {
+            return _indexableExpression;
+        }
+
+        const Utilities::HashedString GetIndex() const {
+            return _index;
+        }
+    };
+
+    class BoundNumericalTableExpression : public BoundExpression {
+        const vector<const BoundExpression *> _expressions;
+    public:
+        BoundNumericalTableExpression(vector<const BoundExpression *> expressions, shared_ptr<ScriptType> type,
+                                      unsigned int start, unsigned int length)
+                : BoundExpression(start, length, std::move(type)),
+                  _expressions(std::move(expressions)) {}
+
+        ~BoundNumericalTableExpression() final {
+            for (auto e: _expressions) {
+                delete e;
+            }
+        }
+
+        const BoundExpressionKind GetKind() const final {
+            return BoundExpressionKind::NumericalTable;
+        }
+
+        const vector<const BoundExpression *> *GetExpressions() const {
+            return &_expressions;
+        }
+    };
+}
 
 #endif //PORYGONLANG_BOUNDEXPRESSION_HPP