1 files changed, 74 insertions, 77 deletions

diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index a33417e536..7dedb6d6f9 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -45,25 +45,27 @@ public:
 	struct ClassNode;
 
 	struct DataType {
-		enum {
+		enum Kind {
 			BUILTIN,
 			NATIVE,
 			SCRIPT,
 			GDSCRIPT,
 			CLASS,
 			UNRESOLVED
-		} kind;
+		};
+
+		Kind kind = UNRESOLVED;
 
-		bool has_type;
-		bool is_constant;
-		bool is_meta_type; // Whether the value can be used as a type
-		bool infer_type;
-		bool may_yield; // For function calls
+		bool has_type = false;
+		bool is_constant = false;
+		bool is_meta_type = false; // Whether the value can be used as a type
+		bool infer_type = false;
+		bool may_yield = false; // For function calls
 
-		Variant::Type builtin_type;
+		Variant::Type builtin_type = Variant::NIL;
 		StringName native_type;
 		Ref<Script> script_type;
-		ClassNode *class_type;
+		ClassNode *class_type = nullptr;
 
 		String to_string() const;
 
@@ -94,19 +96,10 @@ public:
 			return false;
 		}
 
-		DataType() :
-				kind(UNRESOLVED),
-				has_type(false),
-				is_constant(false),
-				is_meta_type(false),
-				infer_type(false),
-				may_yield(false),
-				builtin_type(Variant::NIL),
-				class_type(nullptr) {}
+		DataType() {}
 	};
 
 	struct Node {
-
 		enum Type {
 			TYPE_CLASS,
 			TYPE_FUNCTION,
@@ -145,7 +138,6 @@ public:
 	struct OperatorNode;
 
 	struct ClassNode : public Node {
-
 		bool tool;
 		StringName name;
 		bool extends_used;
@@ -206,7 +198,6 @@ public:
 	};
 
 	struct FunctionNode : public Node {
-
 		bool _static;
 		MultiplayerAPI::RPCMode rpc_mode;
 		bool has_yield;
@@ -235,67 +226,65 @@ public:
 	};
 
 	struct BlockNode : public Node {
-
-		ClassNode *parent_class;
-		BlockNode *parent_block;
+		ClassNode *parent_class = nullptr;
+		BlockNode *parent_block = nullptr;
 		List<Node *> statements;
 		Map<StringName, LocalVarNode *> variables;
-		bool has_return;
+		bool has_return = false;
+		bool can_break = false;
+		bool can_continue = false;
 
-		Node *if_condition; //tiny hack to improve code completion on if () blocks
+		Node *if_condition = nullptr; //tiny hack to improve code completion on if () blocks
 
 		//the following is useful for code completion
 		List<BlockNode *> sub_blocks;
-		int end_line;
+		int end_line = -1;
+
 		BlockNode() {
-			if_condition = nullptr;
 			type = TYPE_BLOCK;
-			end_line = -1;
-			parent_block = nullptr;
-			parent_class = nullptr;
-			has_return = false;
 		}
 	};
 
 	struct TypeNode : public Node {
-
 		Variant::Type vtype;
-		TypeNode() { type = TYPE_TYPE; }
+
+		TypeNode() {
+			type = TYPE_TYPE;
+		}
 	};
+
 	struct BuiltInFunctionNode : public Node {
 		GDScriptFunctions::Function function;
-		BuiltInFunctionNode() { type = TYPE_BUILT_IN_FUNCTION; }
+
+		BuiltInFunctionNode() {
+			type = TYPE_BUILT_IN_FUNCTION;
+		}
 	};
 
 	struct IdentifierNode : public Node {
-
 		StringName name;
-		BlockNode *declared_block; // Simplify lookup by checking if it is declared locally
+		BlockNode *declared_block = nullptr; // Simplify lookup by checking if it is declared locally
 		DataType datatype;
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+
 		IdentifierNode() {
 			type = TYPE_IDENTIFIER;
-			declared_block = nullptr;
 		}
 	};
 
 	struct LocalVarNode : public Node {
-
 		StringName name;
-		Node *assign;
-		OperatorNode *assign_op;
-		int assignments;
-		int usages;
+		Node *assign = nullptr;
+		OperatorNode *assign_op = nullptr;
+		int assignments = 0;
+		int usages = 0;
 		DataType datatype;
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+
 		LocalVarNode() {
 			type = TYPE_LOCAL_VAR;
-			assign = nullptr;
-			assign_op = nullptr;
-			assignments = 0;
-			usages = 0;
 		}
 	};
 
@@ -304,15 +293,18 @@ public:
 		DataType datatype;
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
-		ConstantNode() { type = TYPE_CONSTANT; }
+
+		ConstantNode() {
+			type = TYPE_CONSTANT;
+		}
 	};
 
 	struct ArrayNode : public Node {
-
 		Vector<Node *> elements;
 		DataType datatype;
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+
 		ArrayNode() {
 			type = TYPE_ARRAY;
 			datatype.has_type = true;
@@ -322,9 +314,7 @@ public:
 	};
 
 	struct DictionaryNode : public Node {
-
 		struct Pair {
-
 			Node *key;
 			Node *value;
 		};
@@ -333,6 +323,7 @@ public:
 		DataType datatype;
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+
 		DictionaryNode() {
 			type = TYPE_DICTIONARY;
 			datatype.has_type = true;
@@ -342,7 +333,9 @@ public:
 	};
 
 	struct SelfNode : public Node {
-		SelfNode() { type = TYPE_SELF; }
+		SelfNode() {
+			type = TYPE_SELF;
+		}
 	};
 
 	struct OperatorNode : public Node {
@@ -404,11 +397,12 @@ public:
 		DataType datatype;
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
-		OperatorNode() { type = TYPE_OPERATOR; }
+		OperatorNode() {
+			type = TYPE_OPERATOR;
+		}
 	};
 
 	struct PatternNode : public Node {
-
 		enum PatternType {
 			PT_CONSTANT,
 			PT_BIND,
@@ -454,19 +448,17 @@ public:
 			CF_MATCH
 		};
 
-		CFType cf_type;
+		CFType cf_type = CF_IF;
 		Vector<Node *> arguments;
-		BlockNode *body;
-		BlockNode *body_else;
+		BlockNode *body = nullptr;
+		BlockNode *body_else = nullptr;
 
 		MatchNode *match;
 
 		ControlFlowNode *_else; //used for if
+
 		ControlFlowNode() {
 			type = TYPE_CONTROL_FLOW;
-			cf_type = CF_IF;
-			body = nullptr;
-			body_else = nullptr;
 		}
 	};
 
@@ -476,29 +468,34 @@ public:
 		DataType return_type;
 		virtual DataType get_datatype() const { return return_type; }
 		virtual void set_datatype(const DataType &p_datatype) { return_type = p_datatype; }
-		CastNode() { type = TYPE_CAST; }
+
+		CastNode() {
+			type = TYPE_CAST;
+		}
 	};
 
 	struct AssertNode : public Node {
-		Node *condition;
-		Node *message;
-		AssertNode() :
-				condition(0),
-				message(0) {
+		Node *condition = nullptr;
+		Node *message = nullptr;
+
+		AssertNode() {
 			type = TYPE_ASSERT;
 		}
 	};
 
 	struct BreakpointNode : public Node {
-		BreakpointNode() { type = TYPE_BREAKPOINT; }
+		BreakpointNode() {
+			type = TYPE_BREAKPOINT;
+		}
 	};
 
 	struct NewLineNode : public Node {
-		NewLineNode() { type = TYPE_NEWLINE; }
+		NewLineNode() {
+			type = TYPE_NEWLINE;
+		}
 	};
 
 	struct Expression {
-
 		bool is_op;
 		union {
 			OperatorNode::Operator op;
@@ -553,8 +550,8 @@ private:
 	int pending_newline;
 
 	struct IndentLevel {
-		int indent;
-		int tabs;
+		int indent = 0;
+		int tabs = 0;
 
 		bool is_mixed(IndentLevel other) {
 			return (
@@ -563,9 +560,7 @@ private:
 					(indent < other.indent && tabs > other.tabs));
 		}
 
-		IndentLevel() :
-				indent(0),
-				tabs(0) {}
+		IndentLevel() {}
 
 		IndentLevel(int p_indent, int p_tabs) :
 				indent(p_indent),
@@ -635,7 +630,7 @@ private:
 	DataType _get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const;
 	Variant::Operator _get_variant_operation(const OperatorNode::Operator &p_op) const;
 	bool _get_function_signature(DataType &p_base_type, const StringName &p_function, DataType &r_return_type, List<DataType> &r_arg_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) const;
-	bool _get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type) const;
+	bool _get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type, bool *r_is_const = nullptr) const;
 	bool _is_type_compatible(const DataType &p_container, const DataType &p_expression, bool p_allow_implicit_conversion = false) const;
 	Node *_get_default_value_for_type(const DataType &p_type, int p_line = -1);
 
@@ -648,14 +643,16 @@ private:
 	void _check_block_types(BlockNode *p_block);
 	_FORCE_INLINE_ void _mark_line_as_safe(int p_line) const {
 #ifdef DEBUG_ENABLED
-		if (safe_lines)
+		if (safe_lines) {
 			safe_lines->insert(p_line);
+		}
 #endif // DEBUG_ENABLED
 	}
 	_FORCE_INLINE_ void _mark_line_as_unsafe(int p_line) const {
 #ifdef DEBUG_ENABLED
-		if (safe_lines)
+		if (safe_lines) {
 			safe_lines->erase(p_line);
+		}
 #endif // DEBUG_ENABLED
 	}