Handle bound classes as constants during evaluation

src/Binder/BoundExpressions/BoundExpression.hpp

@@ -1,3 +1,7 @@
+#include <utility>
+
+#include <utility>
+
 
 #ifndef PORYGONLANG_BOUNDEXPRESSION_HPP
 #define PORYGONLANG_BOUNDEXPRESSION_HPP
@@ -29,29 +33,31 @@ enum class BoundExpressionKind{
 };
 
 class BoundExpression{
-    unsigned int _start;
-    unsigned int _length;
-    std::shared_ptr<ScriptType> _type;
+    const unsigned int _start;
+    const unsigned int _length;
+    const shared_ptr<ScriptType> _type;
 public:
-    BoundExpression(unsigned int start, unsigned int length, std::shared_ptr<ScriptType> type){
-        _start = start;
-        _length = length;
-        _type = std::move(type);
+    BoundExpression(unsigned int start, unsigned int length, shared_ptr<ScriptType> type)
+        : _start(start),
+          _length(length),
+          _type(std::move(type))
+    {
     }
+
     virtual ~BoundExpression() = default;
 
-    virtual BoundExpressionKind GetKind() = 0;
-    virtual std::shared_ptr<ScriptType> GetType(){
+    virtual const BoundExpressionKind GetKind() const = 0;
+    virtual const std::shared_ptr<ScriptType> GetType() const{
         return _type;
     };
 
-    unsigned int GetStartPosition(){
+    const unsigned int GetStartPosition() const{
         return _start;
     }
-    unsigned int GetLength(){
+    const unsigned int GetLength() const{
         return _length;
     }
-    unsigned int GetEndPosition(){
+    const unsigned int GetEndPosition() const{
         return _start + _length - 1;
     }
 };
@@ -60,164 +66,172 @@ class BoundBadExpression : public BoundExpression{
 public:
     BoundBadExpression(unsigned int start, unsigned int length) : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Error)){}
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::Bad;
     }
 };
 
 class BoundLiteralIntegerExpression : public BoundExpression{
-    long _value;
+    const long _value;
 public:
     BoundLiteralIntegerExpression(long value, unsigned int start, unsigned int length)
-    : BoundExpression(start, length, make_shared<NumericScriptType>(true, false)){
-        _value = value;
+        : BoundExpression(start, length, make_shared<NumericScriptType>(true, false)),
+          _value(value)
+    {
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::LiteralInteger;
     }
 
-    long GetValue(){
+    const long GetValue() const{
         return _value;
     }
 };
 
 class BoundLiteralFloatExpression : public BoundExpression{
-    double _value;
+    const double _value;
 public:
     BoundLiteralFloatExpression(double value, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, make_shared<NumericScriptType>(true, true)){
-        _value = value;
+            : BoundExpression(start, length, make_shared<NumericScriptType>(true, true)),
+              _value(value)
+    {
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::LiteralFloat;
     }
 
-    double GetValue(){
+    const double GetValue() const{
         return _value;
     }
 };
 
 class BoundLiteralStringExpression : public BoundExpression{
-    string _value;
+    const string _value;
 public:
     BoundLiteralStringExpression(string value, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, make_shared<StringScriptType>(true, HashedString::ConstHash(value.c_str()))){
-        _value = std::move(value);
+            : BoundExpression(start, length, make_shared<StringScriptType>(true, HashedString::ConstHash(value.c_str()))),
+              _value(value)
+    {
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::LiteralString;
     }
 
-    string GetValue(){
+    const string GetValue() const{
         return _value;
     }
 };
 
 class BoundLiteralBoolExpression : public BoundExpression{
-    bool _value;
+    const bool _value;
 public:
     BoundLiteralBoolExpression(bool value, unsigned int start, unsigned int length)
-            : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)){
-        _value = value;
+            : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)),
+              _value(value)
+    {
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::LiteralBool;
     }
 
-    bool GetValue(){
+    const bool GetValue() const{
         return _value;
     }
 };
 
 class BoundVariableExpression : public BoundExpression{
-    BoundVariableKey* _key;
+    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;
+            : BoundExpression(start, length, std::move(type)),
+              _key(key)
+    {
     }
 
     ~BoundVariableExpression() override{
         delete _key;
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::Variable;
     }
 
-    BoundVariableKey* GetKey(){
+    const BoundVariableKey* GetKey() const{
         return _key;
     }
 };
 
 class BoundBinaryExpression : public BoundExpression {
-    BoundExpression* _left;
-    BoundExpression* _right;
-    BoundBinaryOperation _operation;
+    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, result){
-        _left = left;
-        _right = right;
-        _operation = op;
+    : BoundExpression(start, length, std::move(result)),
+      _left(left),
+      _right(right),
+      _operation(op)
+    {
     }
+
     ~BoundBinaryExpression() final{
         delete _left;
         delete _right;
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::Binary;
     }
 
-    BoundExpression* GetLeft(){
+    const BoundExpression* GetLeft() const{
         return _left;
     }
 
-    BoundExpression* GetRight(){
+    const BoundExpression* GetRight() const{
         return _right;
     }
 
-    BoundBinaryOperation GetOperation(){
+    const BoundBinaryOperation GetOperation() const{
         return _operation;
     }
 };
 
 class BoundUnaryExpression : public BoundExpression {
-    BoundExpression* _operand;
-    BoundUnaryOperation  _operation;
+    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, result){
-        _operand = operand;
-        _operation = op;
+        : BoundExpression(start, length, result),
+          _operand(operand),
+          _operation(op)
+    {
     }
 
     ~BoundUnaryExpression() final{
         delete _operand;
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::Unary;
     }
 
-    BoundExpression* GetOperand(){
+    const BoundExpression* GetOperand() const{
         return _operand;
     }
 
-    BoundUnaryOperation GetOperation(){
+    const BoundUnaryOperation GetOperation() const{
         return _operation;
     }
 };
 
 class BoundFunctionCallExpression : public BoundExpression {
-    BoundExpression* _functionExpression;
-    vector<BoundExpression*> _parameters;
+    const BoundExpression* _functionExpression;
+    const vector<BoundExpression*> _parameters;
 public:
     BoundFunctionCallExpression(BoundExpression *functionExpression, vector<BoundExpression *> parameters, shared_ptr<ScriptType> result,
             unsigned int start, unsigned int length)
@@ -230,16 +244,16 @@ public:
         }
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::FunctionCall;
     }
 
-    BoundExpression* GetFunctionExpression(){
+    const BoundExpression* GetFunctionExpression() const{
         return _functionExpression;
     }
 
-    vector<BoundExpression*> GetParameters(){
-        return _parameters;
+    const vector<BoundExpression*>* GetParameters() const{
+        return &_parameters;
     }
 };
 
@@ -256,26 +270,26 @@ public:
         delete _indexExpression;
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::Index;
     }
 
-    BoundExpression* GetIndexableExpression(){
+    BoundExpression* GetIndexableExpression() const{
         return _indexableExpression;
     }
 
-    BoundExpression* GetIndexExpression(){
+    BoundExpression* GetIndexExpression() const{
         return _indexExpression;
     }
 };
 
 class BoundNumericalTableExpression : public BoundExpression{
-    vector<BoundExpression*> _expressions;
+    const vector<BoundExpression*> _expressions;
 public:
     BoundNumericalTableExpression(vector<BoundExpression*> expressions, shared_ptr<ScriptType> type, unsigned int start, unsigned int length)
-        : BoundExpression(start, length, std::move(type)){
-        _expressions = std::move(expressions);
-    }
+        : BoundExpression(start, length, std::move(type)),
+          _expressions(std::move(expressions))
+        {}
 
     ~BoundNumericalTableExpression() final{
         for (auto e: _expressions){
@@ -283,12 +297,12 @@ public:
         }
     }
 
-    BoundExpressionKind GetKind() final{
+    const BoundExpressionKind GetKind() const final{
         return BoundExpressionKind ::NumericalTable;
     }
 
-    vector<BoundExpression*> GetExpressions(){
-        return _expressions;
+    const vector<BoundExpression*>* GetExpressions() const{
+        return &_expressions;
     }
 };