From 5dbf1809c6e3e905b94b8764e99491e608122261 Mon Sep 17 00:00:00 2001
From: Rémi Verschelde
Date: Sun, 5 Mar 2017 16:44:50 +0100
Subject: A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code
---
 modules/gdscript/gd_editor.cpp | 2016 ++++++++++++++++++----------------------
 1 file changed, 915 insertions(+), 1101 deletions(-)

(limited to 'modules/gdscript/gd_editor.cpp')

diff --git a/modules/gdscript/gd_editor.cpp b/modules/gdscript/gd_editor.cpp
index 9dd41847d..bd428941e 100644
--- a/modules/gdscript/gd_editor.cpp
+++ b/modules/gdscript/gd_editor.cpp
@@ -26,8 +26,8 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#include "gd_script.h"
 #include "gd_compiler.h"
+#include "gd_script.h"
 #include "global_config.h"
 #include "os/file_access.h"
 
@@ -35,73 +35,64 @@ void GDScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const
 
 	p_delimiters->push_back("#");
 	p_delimiters->push_back("\"\"\" \"\"\"");
-
 }
 void GDScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
 
 	p_delimiters->push_back("\" \"");
 	p_delimiters->push_back("' '");
-
-
 }
-Ref<Script> GDScriptLanguage::get_template(const String& p_class_name, const String& p_base_class_name) const {
+Ref<Script> GDScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
 
-	String _template = String()+
-	"extends %BASE%\n\n"+
-	"# class member variables go here, for example:\n"+
-	"# var a = 2\n"+
-	"# var b = \"textvar\"\n\n"+
-	"func _ready():\n"+
-	"\t# Called every time the node is added to the scene.\n"+
-	"\t# Initialization here\n"+
-	"\tpass\n";
+	String _template = String() +
+					   "extends %BASE%\n\n" +
+					   "# class member variables go here, for example:\n" +
+					   "# var a = 2\n" +
+					   "# var b = \"textvar\"\n\n" +
+					   "func _ready():\n" +
+					   "\t# Called every time the node is added to the scene.\n" +
+					   "\t# Initialization here\n" +
+					   "\tpass\n";
 
-	_template = _template.replace("%BASE%",p_base_class_name);
+	_template = _template.replace("%BASE%", p_base_class_name);
 
 	Ref<GDScript> script;
 	script.instance();
 	script->set_source_code(_template);
 
 	return script;
-
 }
 
-
-
-
-bool GDScriptLanguage::validate(const String& p_script, int &r_line_error,int &r_col_error,String& r_test_error, const String& p_path,List<String> *r_functions) const {
+bool GDScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions) const {
 
 	GDParser parser;
 
-	Error err = parser.parse(p_script,p_path.get_base_dir(),true,p_path);
+	Error err = parser.parse(p_script, p_path.get_base_dir(), true, p_path);
 	if (err) {
-		r_line_error=parser.get_error_line();
-		r_col_error=parser.get_error_column();
-		r_test_error=parser.get_error();
+		r_line_error = parser.get_error_line();
+		r_col_error = parser.get_error_column();
+		r_test_error = parser.get_error();
 		return false;
 	} else {
 
 		const GDParser::Node *root = parser.get_parse_tree();
-		ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,false);
+		ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, false);
 
-		const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode*>(root);
-		Map<int,String> funcs;
-		for(int i=0;i<cl->functions.size();i++) {
+		const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode *>(root);
+		Map<int, String> funcs;
+		for (int i = 0; i < cl->functions.size(); i++) {
 
-			funcs[cl->functions[i]->line]=cl->functions[i]->name;
+			funcs[cl->functions[i]->line] = cl->functions[i]->name;
 		}
 
-		for(int i=0;i<cl->static_functions.size();i++) {
+		for (int i = 0; i < cl->static_functions.size(); i++) {
 
-			funcs[cl->static_functions[i]->line]=cl->static_functions[i]->name;
+			funcs[cl->static_functions[i]->line] = cl->static_functions[i]->name;
 		}
 
-		for (Map<int,String>::Element *E=funcs.front();E;E=E->next()) {
+		for (Map<int, String>::Element *E = funcs.front(); E; E = E->next()) {
 
-			r_functions->push_back(E->get()+":"+itos(E->key()));
+			r_functions->push_back(E->get() + ":" + itos(E->key()));
 		}
-
-
 	}
 
 	return true;
@@ -112,142 +103,133 @@ bool GDScriptLanguage::has_named_classes() const {
 	return false;
 }
 
-int GDScriptLanguage::find_function(const String& p_function,const String& p_code) const {
+int GDScriptLanguage::find_function(const String &p_function, const String &p_code) const {
 
 	GDTokenizerText tokenizer;
 	tokenizer.set_code(p_code);
-	int indent=0;
-	while(tokenizer.get_token()!=GDTokenizer::TK_EOF && tokenizer.get_token()!=GDTokenizer::TK_ERROR) {
+	int indent = 0;
+	while (tokenizer.get_token() != GDTokenizer::TK_EOF && tokenizer.get_token() != GDTokenizer::TK_ERROR) {
 
-		if (tokenizer.get_token()==GDTokenizer::TK_NEWLINE) {
-			indent=tokenizer.get_token_line_indent();
+		if (tokenizer.get_token() == GDTokenizer::TK_NEWLINE) {
+			indent = tokenizer.get_token_line_indent();
 		}
 		//print_line("TOKEN: "+String(GDTokenizer::get_token_name(tokenizer.get_token())));
-		if (indent==0 && tokenizer.get_token()==GDTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1)==GDTokenizer::TK_IDENTIFIER) {
+		if (indent == 0 && tokenizer.get_token() == GDTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1) == GDTokenizer::TK_IDENTIFIER) {
 
 			String identifier = tokenizer.get_token_identifier(1);
-			if (identifier==p_function) {
+			if (identifier == p_function) {
 				return tokenizer.get_token_line();
 			}
 		}
 		tokenizer.advance();
 		//print_line("NEXT: "+String(GDTokenizer::get_token_name(tokenizer.get_token())));
-
 	}
 	return -1;
 }
 
 Script *GDScriptLanguage::create_script() const {
 
-	return memnew( GDScript );
+	return memnew(GDScript);
 }
 
 /* DEBUGGER FUNCTIONS */
 
-
-bool GDScriptLanguage::debug_break_parse(const String& p_file, int p_line,const String& p_error) {
+bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
 	//break because of parse error
 
-    if (ScriptDebugger::get_singleton() && Thread::get_caller_ID()==Thread::get_main_ID()) {
-
-	_debug_parse_err_line=p_line;
-	_debug_parse_err_file=p_file;
-	_debug_error=p_error;
-	ScriptDebugger::get_singleton()->debug(this,false);
-	return true;
-    } else {
-	return false;
-    }
+	if (ScriptDebugger::get_singleton() && Thread::get_caller_ID() == Thread::get_main_ID()) {
 
+		_debug_parse_err_line = p_line;
+		_debug_parse_err_file = p_file;
+		_debug_error = p_error;
+		ScriptDebugger::get_singleton()->debug(this, false);
+		return true;
+	} else {
+		return false;
+	}
 }
 
-bool GDScriptLanguage::debug_break(const String& p_error,bool p_allow_continue) {
-
-    if (ScriptDebugger::get_singleton() && Thread::get_caller_ID()==Thread::get_main_ID()) {
+bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
 
-	_debug_parse_err_line=-1;
-	_debug_parse_err_file="";
-	_debug_error=p_error;
-	ScriptDebugger::get_singleton()->debug(this,p_allow_continue);
-	return true;
-    } else {
-	return false;
-    }
+	if (ScriptDebugger::get_singleton() && Thread::get_caller_ID() == Thread::get_main_ID()) {
 
+		_debug_parse_err_line = -1;
+		_debug_parse_err_file = "";
+		_debug_error = p_error;
+		ScriptDebugger::get_singleton()->debug(this, p_allow_continue);
+		return true;
+	} else {
+		return false;
+	}
 }
 
 String GDScriptLanguage::debug_get_error() const {
 
-    return _debug_error;
+	return _debug_error;
 }
 
 int GDScriptLanguage::debug_get_stack_level_count() const {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return 1;
 
-
 	return _debug_call_stack_pos;
 }
 int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return _debug_parse_err_line;
 
-    ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,-1);
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, -1);
 
-    int l = _debug_call_stack_pos - p_level -1;
-
-    return *(_call_stack[l].line);
+	int l = _debug_call_stack_pos - p_level - 1;
 
+	return *(_call_stack[l].line);
 }
 String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return "";
 
-    ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,"");
-    int l = _debug_call_stack_pos - p_level -1;
-    return _call_stack[l].function->get_name();
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
+	int l = _debug_call_stack_pos - p_level - 1;
+	return _call_stack[l].function->get_name();
 }
 String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return _debug_parse_err_file;
 
-    ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,"");
-    int l = _debug_call_stack_pos - p_level -1;
-    return _call_stack[l].function->get_source();
-
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
+	int l = _debug_call_stack_pos - p_level - 1;
+	return _call_stack[l].function->get_source();
 }
-void GDScriptLanguage::debug_get_stack_level_locals(int p_level,List<String> *p_locals, List<Variant> *p_values, int p_max_subitems,int p_max_depth) {
+void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return;
 
-    ERR_FAIL_INDEX(p_level,_debug_call_stack_pos);
-    int l = _debug_call_stack_pos - p_level -1;
+	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
+	int l = _debug_call_stack_pos - p_level - 1;
 
-    GDFunction *f = _call_stack[l].function;
+	GDFunction *f = _call_stack[l].function;
 
-    List<Pair<StringName,int> > locals;
+	List<Pair<StringName, int> > locals;
 
-    f->debug_get_stack_member_state(*_call_stack[l].line,&locals);
-    for( List<Pair<StringName,int> >::Element *E = locals.front();E;E=E->next() ) {
-
-	p_locals->push_back(E->get().first);
-	p_values->push_back(_call_stack[l].stack[E->get().second]);
-    }
+	f->debug_get_stack_member_state(*_call_stack[l].line, &locals);
+	for (List<Pair<StringName, int> >::Element *E = locals.front(); E; E = E->next()) {
 
+		p_locals->push_back(E->get().first);
+		p_values->push_back(_call_stack[l].stack[E->get().second]);
+	}
 }
-void GDScriptLanguage::debug_get_stack_level_members(int p_level,List<String> *p_members, List<Variant> *p_values, int p_max_subitems,int p_max_depth) {
+void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return;
 
-	ERR_FAIL_INDEX(p_level,_debug_call_stack_pos);
-	int l = _debug_call_stack_pos - p_level -1;
-
+	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
+	int l = _debug_call_stack_pos - p_level - 1;
 
 	GDInstance *instance = _call_stack[l].instance;
 
@@ -255,25 +237,23 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level,List<String> *p
 		return;
 
 	Ref<GDScript> script = instance->get_script();
-	ERR_FAIL_COND( script.is_null() );
-
+	ERR_FAIL_COND(script.is_null());
 
-	const Map<StringName,GDScript::MemberInfo>& mi = script->debug_get_member_indices();
+	const Map<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices();
 
-	for(const Map<StringName,GDScript::MemberInfo>::Element *E=mi.front();E;E=E->next()) {
+	for (const Map<StringName, GDScript::MemberInfo>::Element *E = mi.front(); E; E = E->next()) {
 
 		p_members->push_back(E->key());
-		p_values->push_back( instance->debug_get_member_by_index(E->get().index));
+		p_values->push_back(instance->debug_get_member_by_index(E->get().index));
 	}
-
 }
-void GDScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems,int p_max_depth) {
+void GDScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
 
-    //no globals are really reachable in gdscript
+	//no globals are really reachable in gdscript
 }
-String GDScriptLanguage::debug_parse_stack_level_expression(int p_level,const String& p_expression,int p_max_subitems,int p_max_depth) {
+String GDScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
 
-	if (_debug_parse_err_line>=0)
+	if (_debug_parse_err_line >= 0)
 		return "";
 	return "";
 }
@@ -283,11 +263,9 @@ void GDScriptLanguage::get_recognized_extensions(List<String> *p_extensions) con
 	p_extensions->push_back("gd");
 }
 
-
 void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
 
-
-	for(int i=0;i<GDFunctions::FUNC_MAX;i++) {
+	for (int i = 0; i < GDFunctions::FUNC_MAX; i++) {
 
 		p_functions->push_back(GDFunctions::get_info(GDFunctions::Function(i)));
 	}
@@ -295,33 +273,33 @@ void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const
 	//not really "functions", but..
 	{
 		MethodInfo mi;
-		mi.name="preload:Resource";
-		mi.arguments.push_back(PropertyInfo(Variant::STRING,"path"));
-		mi.return_val=PropertyInfo(Variant::OBJECT,"",PROPERTY_HINT_RESOURCE_TYPE,"Resource");
+		mi.name = "preload:Resource";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "path"));
+		mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "Resource");
 		p_functions->push_back(mi);
 	}
 	{
 		MethodInfo mi;
-		mi.name="yield:GDFunctionState";
-		mi.arguments.push_back(PropertyInfo(Variant::OBJECT,"object"));
-		mi.arguments.push_back(PropertyInfo(Variant::STRING,"signal"));
+		mi.name = "yield:GDFunctionState";
+		mi.arguments.push_back(PropertyInfo(Variant::OBJECT, "object"));
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "signal"));
 		mi.default_arguments.push_back(Variant::NIL);
 		mi.default_arguments.push_back(Variant::STRING);
 		p_functions->push_back(mi);
 	}
 	{
 		MethodInfo mi;
-		mi.name="assert";
-		mi.arguments.push_back(PropertyInfo(Variant::BOOL,"condition"));
+		mi.name = "assert";
+		mi.arguments.push_back(PropertyInfo(Variant::BOOL, "condition"));
 		p_functions->push_back(mi);
 	}
 }
 
-void GDScriptLanguage::get_public_constants(List<Pair<String,Variant> > *p_constants) const {
+void GDScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const {
 
-	Pair<String,Variant> pi;
-	pi.first="PI";
-	pi.second=Math_PI;
+	Pair<String, Variant> pi;
+	pi.first = "PI";
+	pi.second = Math_PI;
 	p_constants->push_back(pi);
 
 	Pair<String, Variant> infinity;
@@ -335,22 +313,21 @@ void GDScriptLanguage::get_public_constants(List<Pair<String,Variant> > *p_const
 	p_constants->push_back(nan);
 }
 
-String GDScriptLanguage::make_function(const String& p_class,const String& p_name,const PoolStringArray& p_args) const {
+String GDScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
 
-	String s="func "+p_name+"(";
+	String s = "func " + p_name + "(";
 	if (p_args.size()) {
-		s+=" ";
-		for(int i=0;i<p_args.size();i++) {
-			if (i>0)
-				s+=", ";
-			s+=p_args[i].get_slice(":",0);
+		s += " ";
+		for (int i = 0; i < p_args.size(); i++) {
+			if (i > 0)
+				s += ", ";
+			s += p_args[i].get_slice(":", 0);
 		}
-		s+=" ";
+		s += " ";
 	}
-	s+="):\n\tpass # replace with function body\n";
+	s += "):\n\tpass # replace with function body\n";
 
 	return s;
-
 }
 
 #if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED)
@@ -361,17 +338,14 @@ struct GDCompletionIdentifier {
 	Ref<GDScript> script;
 	Variant::Type type;
 	Variant value; //im case there is a value, also return it
-
 };
 
-
-
-static GDCompletionIdentifier _get_type_from_variant(const Variant& p_variant) {
+static GDCompletionIdentifier _get_type_from_variant(const Variant &p_variant) {
 
 	GDCompletionIdentifier t;
-	t.type=p_variant.get_type();
-	t.value=p_variant;
-	if (p_variant.get_type()==Variant::OBJECT) {
+	t.type = p_variant.get_type();
+	t.value = p_variant;
+	if (p_variant.get_type() == Variant::OBJECT) {
 		Object *obj = p_variant;
 		if (obj) {
 			/*
@@ -380,19 +354,19 @@ static GDCompletionIdentifier _get_type_from_variant(const Variant& p_variant) {
 				t.value=Variant();
 			} else {
 			*/
-				t.obj_type=obj->get_class();
+			t.obj_type = obj->get_class();
 			//}
 		}
 	}
 	return t;
 }
 
-static GDCompletionIdentifier _get_type_from_pinfo(const PropertyInfo& p_info) {
+static GDCompletionIdentifier _get_type_from_pinfo(const PropertyInfo &p_info) {
 
 	GDCompletionIdentifier t;
-	t.type=p_info.type;
-	if (p_info.hint==PROPERTY_HINT_RESOURCE_TYPE) {
-		t.obj_type=p_info.hint_string;
+	t.type = p_info.type;
+	if (p_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+		t.obj_type = p_info.hint_string;
 	}
 	return t;
 }
@@ -402,15 +376,11 @@ struct GDCompletionContext {
 	const GDParser::ClassNode *_class;
 	const GDParser::FunctionNode *function;
 	const GDParser::BlockNode *block;
-	Object* base;
+	Object *base;
 	String base_path;
-
 };
 
-
-static Ref<Reference> _get_parent_class(GDCompletionContext& context) {
-
-
+static Ref<Reference> _get_parent_class(GDCompletionContext &context) {
 
 	if (context._class->extends_used) {
 		//do inheritance
@@ -419,12 +389,12 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) {
 		Ref<GDScript> script;
 		Ref<GDNativeClass> native;
 
-		if (path!="") {
+		if (path != "") {
 			//path (and optionally subclasses)
 
 			if (path.is_rel_path()) {
 
-				path=context.base_path.plus_file(path);
+				path = context.base_path.plus_file(path);
 			}
 
 			if (ScriptCodeCompletionCache::get_sigleton())
@@ -443,12 +413,12 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) {
 
 			if (context._class->extends_class.size()) {
 
-				for(int i=0;i<context._class->extends_class.size();i++) {
+				for (int i = 0; i < context._class->extends_class.size(); i++) {
 
 					String sub = context._class->extends_class[i];
 					if (script->get_subclasses().has(sub)) {
 
-						script=script->get_subclasses()[sub];
+						script = script->get_subclasses()[sub];
 					} else {
 
 						return REF();
@@ -461,17 +431,16 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) {
 
 		} else {
 
-			if (context._class->extends_class.size()==0) {
+			if (context._class->extends_class.size() == 0) {
 				ERR_PRINT("BUG");
 				return REF();
 			}
 
-			String base=context._class->extends_class[0];
+			String base = context._class->extends_class[0];
 
-			if (context._class->extends_class.size()>1) {
+			if (context._class->extends_class.size() > 1) {
 
 				return REF();
-
 			}
 			//if not found, try engine classes
 			if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
@@ -482,22 +451,19 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) {
 			int base_idx = GDScriptLanguage::get_singleton()->get_global_map()[base];
 			native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx];
 			return native;
-
 		}
-
 	}
 
 	return Ref<Reference>();
 }
 
-
-static GDCompletionIdentifier _get_native_class(GDCompletionContext& context) {
+static GDCompletionIdentifier _get_native_class(GDCompletionContext &context) {
 
 	//eeh...
 	GDCompletionIdentifier id;
-	id.type=Variant::NIL;
+	id.type = Variant::NIL;
 
-	REF pc  = _get_parent_class(context);
+	REF pc = _get_parent_class(context);
 	if (!pc.is_valid()) {
 		return id;
 	}
@@ -507,204 +473,191 @@ static GDCompletionIdentifier _get_native_class(GDCompletionContext& context) {
 	if (s.is_null() && nc.is_null()) {
 		return id;
 	}
-	while(!s.is_null()) {
-		nc=s->get_native();
-		s=s->get_base();
+	while (!s.is_null()) {
+		nc = s->get_native();
+		s = s->get_base();
 	}
 	if (nc.is_null()) {
 		return id;
 	}
 
-
-
-	id.type=Variant::OBJECT;
+	id.type = Variant::OBJECT;
 	if (context.base)
-		id.value=context.base;
-	id.obj_type=nc->get_name();
+		id.value = context.base;
+	id.obj_type = nc->get_name();
 	return id;
 }
 
-static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const StringName& p_identifier,GDCompletionIdentifier &r_type);
-
+static bool _guess_identifier_type(GDCompletionContext &context, int p_line, const StringName &p_identifier, GDCompletionIdentifier &r_type);
 
-static bool _guess_expression_type(GDCompletionContext& context,const GDParser::Node* p_node,int p_line,GDCompletionIdentifier &r_type) {
+static bool _guess_expression_type(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, GDCompletionIdentifier &r_type) {
 
+	if (p_node->type == GDParser::Node::TYPE_CONSTANT) {
 
-	if (p_node->type==GDParser::Node::TYPE_CONSTANT) {
+		const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(p_node);
 
-		const GDParser::ConstantNode *cn=static_cast<const GDParser::ConstantNode *>(p_node);
-
-		r_type=_get_type_from_variant(cn->value);
+		r_type = _get_type_from_variant(cn->value);
 
 		return true;
-	} else if (p_node->type==GDParser::Node::TYPE_DICTIONARY) {
-
-		r_type.type=Variant::DICTIONARY;
+	} else if (p_node->type == GDParser::Node::TYPE_DICTIONARY) {
 
+		r_type.type = Variant::DICTIONARY;
 
 		//what the heck, fill it anyway
 		const GDParser::DictionaryNode *an = static_cast<const GDParser::DictionaryNode *>(p_node);
 		Dictionary d;
-		for(int i=0;i<an->elements.size();i++) {
+		for (int i = 0; i < an->elements.size(); i++) {
 			GDCompletionIdentifier k;
-			if (_guess_expression_type(context,an->elements[i].key,p_line,k) && k.value.get_type()!=Variant::NIL) {
+			if (_guess_expression_type(context, an->elements[i].key, p_line, k) && k.value.get_type() != Variant::NIL) {
 				GDCompletionIdentifier v;
-				if (_guess_expression_type(context,an->elements[i].value,p_line,v)) {
-					d[k.value]=v.value;
+				if (_guess_expression_type(context, an->elements[i].value, p_line, v)) {
+					d[k.value] = v.value;
 				}
-
 			}
 		}
-		r_type.value=d;
+		r_type.value = d;
 		return true;
-	} else if (p_node->type==GDParser::Node::TYPE_ARRAY) {
+	} else if (p_node->type == GDParser::Node::TYPE_ARRAY) {
 
-		r_type.type=Variant::ARRAY;
+		r_type.type = Variant::ARRAY;
 		//what the heck, fill it anyway
 		const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode *>(p_node);
 		Array arr;
 		arr.resize(an->elements.size());
-		for(int i=0;i<an->elements.size();i++) {
+		for (int i = 0; i < an->elements.size(); i++) {
 			GDCompletionIdentifier ci;
-			if (_guess_expression_type(context,an->elements[i],p_line,ci)) {
-				arr[i]=ci.value;
+			if (_guess_expression_type(context, an->elements[i], p_line, ci)) {
+				arr[i] = ci.value;
 			}
 		}
-		r_type.value=arr;
+		r_type.value = arr;
 		return true;
 
-	} else if (p_node->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
+	} else if (p_node->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
 
-		MethodInfo mi = GDFunctions::get_info(static_cast<const GDParser::BuiltInFunctionNode*>(p_node)->function);
-		r_type=_get_type_from_pinfo(mi.return_val);
+		MethodInfo mi = GDFunctions::get_info(static_cast<const GDParser::BuiltInFunctionNode *>(p_node)->function);
+		r_type = _get_type_from_pinfo(mi.return_val);
 
 		return true;
-	} else if (p_node->type==GDParser::Node::TYPE_IDENTIFIER) {
+	} else if (p_node->type == GDParser::Node::TYPE_IDENTIFIER) {
 
-		return _guess_identifier_type(context,p_line-1,static_cast<const GDParser::IdentifierNode *>(p_node)->name,r_type);
-	} else if (p_node->type==GDParser::Node::TYPE_SELF) {
+		return _guess_identifier_type(context, p_line - 1, static_cast<const GDParser::IdentifierNode *>(p_node)->name, r_type);
+	} else if (p_node->type == GDParser::Node::TYPE_SELF) {
 		//eeh...
 
-		r_type=_get_native_class(context);
-		return r_type.type!=Variant::NIL;
-
-	} else if (p_node->type==GDParser::Node::TYPE_OPERATOR) {
+		r_type = _get_native_class(context);
+		return r_type.type != Variant::NIL;
 
+	} else if (p_node->type == GDParser::Node::TYPE_OPERATOR) {
 
 		const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(p_node);
-		if (op->op==GDParser::OperatorNode::OP_CALL) {
-			if (op->arguments[0]->type==GDParser::Node::TYPE_TYPE) {
+		if (op->op == GDParser::OperatorNode::OP_CALL) {
+			if (op->arguments[0]->type == GDParser::Node::TYPE_TYPE) {
 
 				const GDParser::TypeNode *tn = static_cast<const GDParser::TypeNode *>(op->arguments[0]);
-				r_type.type=tn->vtype;
+				r_type.type = tn->vtype;
 				return true;
-			} else if (op->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
-
+			} else if (op->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
 
 				const GDParser::BuiltInFunctionNode *bin = static_cast<const GDParser::BuiltInFunctionNode *>(op->arguments[0]);
-				return _guess_expression_type(context,bin,p_line,r_type);
-
-			} else if (op->arguments.size()>1 && op->arguments[1]->type==GDParser::Node::TYPE_IDENTIFIER) {
+				return _guess_expression_type(context, bin, p_line, r_type);
 
+			} else if (op->arguments.size() > 1 && op->arguments[1]->type == GDParser::Node::TYPE_IDENTIFIER) {
 
 				GDCompletionIdentifier base;
-				if (!_guess_expression_type(context,op->arguments[0],p_line,base))
+				if (!_guess_expression_type(context, op->arguments[0], p_line, base))
 					return false;
 
 				StringName id = static_cast<const GDParser::IdentifierNode *>(op->arguments[1])->name;
 
-				if (base.type==Variant::OBJECT) {
+				if (base.type == Variant::OBJECT) {
 
-					if (id.operator String()=="new" && base.value.get_type()==Variant::OBJECT) {
+					if (id.operator String() == "new" && base.value.get_type() == Variant::OBJECT) {
 						Object *obj = base.value;
 						if (obj && obj->cast_to<GDNativeClass>()) {
 							GDNativeClass *gdnc = obj->cast_to<GDNativeClass>();
-							r_type.type=Variant::OBJECT;
-							r_type.value=Variant();
-							r_type.obj_type=gdnc->get_name();
+							r_type.type = Variant::OBJECT;
+							r_type.value = Variant();
+							r_type.obj_type = gdnc->get_name();
 							return true;
 						}
 					}
 
-					if (ClassDB::has_method(base.obj_type,id)) {
+					if (ClassDB::has_method(base.obj_type, id)) {
 
 #ifdef TOOLS_ENABLED
-						MethodBind *mb = ClassDB::get_method(base.obj_type,id);
+						MethodBind *mb = ClassDB::get_method(base.obj_type, id);
 						PropertyInfo pi = mb->get_argument_info(-1);
 
 						//try calling the function if constant and all args are constant, should not crash..
 						Object *baseptr = base.value;
 
+						if (mb->is_const() && pi.type == Variant::OBJECT) {
 
-						if (mb->is_const() && pi.type==Variant::OBJECT) {
-
-							bool all_valid=true;
+							bool all_valid = true;
 							Vector<Variant> args;
-							for(int i=2;i<op->arguments.size();i++) {
+							for (int i = 2; i < op->arguments.size(); i++) {
 								GDCompletionIdentifier arg;
 
-								if (_guess_expression_type(context,op->arguments[i],p_line,arg)) {
-									if (arg.value.get_type()!=Variant::NIL && arg.value.get_type()!=Variant::OBJECT) { // calling with object seems dangerous, i don' t know
+								if (_guess_expression_type(context, op->arguments[i], p_line, arg)) {
+									if (arg.value.get_type() != Variant::NIL && arg.value.get_type() != Variant::OBJECT) { // calling with object seems dangerous, i don' t know
 										args.push_back(arg.value);
 									} else {
-										all_valid=false;
+										all_valid = false;
 										break;
 									}
 								} else {
-									all_valid=false;
+									all_valid = false;
 								}
 							}
 
-							if (all_valid && String(id)=="get_node" && ClassDB::is_parent_class(base.obj_type,"Node") && args.size()) {
+							if (all_valid && String(id) == "get_node" && ClassDB::is_parent_class(base.obj_type, "Node") && args.size()) {
 
-								String arg1=args[0];
+								String arg1 = args[0];
 								if (arg1.begins_with("/root/")) {
-									String which = arg1.get_slice("/",2);
-									if (which!="") {
+									String which = arg1.get_slice("/", 2);
+									if (which != "") {
 										List<PropertyInfo> props;
 										GlobalConfig::get_singleton()->get_property_list(&props);
 										//print_line("find singleton");
 
-										for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+										for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 
 											String s = E->get().name;
 											if (!s.begins_with("autoload/"))
 												continue;
 											//print_line("found "+s);
-											String name = s.get_slice("/",1);
+											String name = s.get_slice("/", 1);
 											//print_line("name: "+name+", which: "+which);
-											if (name==which) {
+											if (name == which) {
 												String script = GlobalConfig::get_singleton()->get(s);
 
 												if (!script.begins_with("res://")) {
-													script="res://"+script;
+													script = "res://" + script;
 												}
 
 												if (!script.ends_with(".gd")) {
 													//not a script, try find the script anyway,
 													//may have some success
-													script=script.get_basename()+".gd";
+													script = script.get_basename() + ".gd";
 												}
 
 												if (FileAccess::exists(script)) {
 
 													//print_line("is a script");
 
-
 													Ref<Script> scr;
 													if (ScriptCodeCompletionCache::get_sigleton())
 														scr = ScriptCodeCompletionCache::get_sigleton()->get_cached_resource(script);
 													else
 														scr = ResourceLoader::load(script);
 
-
-													r_type.obj_type="Node";
-													r_type.type=Variant::OBJECT;
-													r_type.script=scr;
-													r_type.value=Variant();
+													r_type.obj_type = "Node";
+													r_type.type = Variant::OBJECT;
+													r_type.script = scr;
+													r_type.value = Variant();
 
 													return true;
-
 												}
 											}
 										}
@@ -712,40 +665,34 @@ static bool _guess_expression_type(GDCompletionContext& context,const GDParser::
 								}
 							}
 
-
-
 							if (baseptr) {
 
 								if (all_valid) {
-									Vector<const Variant*> argptr;
-									for(int i=0;i<args.size();i++) {
+									Vector<const Variant *> argptr;
+									for (int i = 0; i < args.size(); i++) {
 										argptr.push_back(&args[i]);
 									}
 
 									Variant::CallError ce;
-									Variant ret=mb->call(baseptr,argptr.ptr(),argptr.size(),ce);
+									Variant ret = mb->call(baseptr, argptr.ptr(), argptr.size(), ce);
 
+									if (ce.error == Variant::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
 
-									if (ce.error==Variant::CallError::CALL_OK && ret.get_type()!=Variant::NIL) {
+										if (ret.get_type() != Variant::OBJECT || ret.operator Object *() != NULL) {
 
-										if (ret.get_type()!=Variant::OBJECT || ret.operator Object*()!=NULL) {
-
-											r_type=_get_type_from_variant(ret);
+											r_type = _get_type_from_variant(ret);
 											return true;
 										}
 									}
-
 								}
 							}
 						}
 
-						r_type.type=pi.type;
-						if (pi.hint==PROPERTY_HINT_RESOURCE_TYPE) {
-							r_type.obj_type=pi.hint_string;
+						r_type.type = pi.type;
+						if (pi.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+							r_type.obj_type = pi.hint_string;
 						}
 
-
-
 						return true;
 #else
 						return false;
@@ -756,115 +703,108 @@ static bool _guess_expression_type(GDCompletionContext& context,const GDParser::
 				} else {
 					//method for some variant..
 					Variant::CallError ce;
-					Variant v = Variant::construct(base.type,NULL,0,ce);
+					Variant v = Variant::construct(base.type, NULL, 0, ce);
 					List<MethodInfo> mi;
 					v.get_method_list(&mi);
-					for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) {
-
-						if (!E->get().name.begins_with("_") && E->get().name==id.operator String()) {
+					for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) {
 
+						if (!E->get().name.begins_with("_") && E->get().name == id.operator String()) {
 
 							MethodInfo mi = E->get();
-							r_type.type=mi.return_val.type;
-							if (mi.return_val.hint==PROPERTY_HINT_RESOURCE_TYPE) {
-								r_type.obj_type=mi.return_val.hint_string;
+							r_type.type = mi.return_val.type;
+							if (mi.return_val.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+								r_type.obj_type = mi.return_val.hint_string;
 							}
 							return true;
 						}
 					}
-
 				}
-
-
 			}
-		} else if (op->op==GDParser::OperatorNode::OP_INDEX || op->op==GDParser::OperatorNode::OP_INDEX_NAMED) {
+		} else if (op->op == GDParser::OperatorNode::OP_INDEX || op->op == GDParser::OperatorNode::OP_INDEX_NAMED) {
 
 			GDCompletionIdentifier p1;
 			GDCompletionIdentifier p2;
 
+			if (op->op == GDParser::OperatorNode::OP_INDEX_NAMED) {
 
-
-			if (op->op==GDParser::OperatorNode::OP_INDEX_NAMED) {
-
-				if (op->arguments[1]->type==GDParser::Node::TYPE_IDENTIFIER) {
-					String id = static_cast<const GDParser::IdentifierNode*>(op->arguments[1])->name;
-					p2.type=Variant::STRING;
-					p2.value=id;
+				if (op->arguments[1]->type == GDParser::Node::TYPE_IDENTIFIER) {
+					String id = static_cast<const GDParser::IdentifierNode *>(op->arguments[1])->name;
+					p2.type = Variant::STRING;
+					p2.value = id;
 				}
 
 			} else {
 				if (op->arguments[1]) {
-					if (!_guess_expression_type(context,op->arguments[1],p_line,p2)) {
+					if (!_guess_expression_type(context, op->arguments[1], p_line, p2)) {
 
 						return false;
 					}
 				}
 			}
 
-			if (op->arguments[0]->type==GDParser::Node::TYPE_ARRAY) {
+			if (op->arguments[0]->type == GDParser::Node::TYPE_ARRAY) {
 
 				const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode *>(op->arguments[0]);
 				if (p2.value.is_num()) {
 					int index = p2.value;
-					if (index<0 || index>=an->elements.size())
+					if (index < 0 || index >= an->elements.size())
 						return false;
-					return _guess_expression_type(context,an->elements[index],p_line,r_type);
+					return _guess_expression_type(context, an->elements[index], p_line, r_type);
 				}
 
-			} else if (op->arguments[0]->type==GDParser::Node::TYPE_DICTIONARY) {
+			} else if (op->arguments[0]->type == GDParser::Node::TYPE_DICTIONARY) {
 
 				const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode *>(op->arguments[0]);
 
-				if (p2.value.get_type()==Variant::NIL)
+				if (p2.value.get_type() == Variant::NIL)
 					return false;
 
-				for(int i=0;i<dn->elements.size();i++) {
+				for (int i = 0; i < dn->elements.size(); i++) {
 
 					GDCompletionIdentifier k;
 
-					if (!_guess_expression_type(context,dn->elements[i].key,p_line,k)) {
+					if (!_guess_expression_type(context, dn->elements[i].key, p_line, k)) {
 
 						return false;
 					}
 
-					if (k.value.get_type()==Variant::NIL)
+					if (k.value.get_type() == Variant::NIL)
 						return false;
 
-					if (k.value==p2.value) {
+					if (k.value == p2.value) {
 
-						return _guess_expression_type(context,dn->elements[i].value,p_line,r_type);
+						return _guess_expression_type(context, dn->elements[i].value, p_line, r_type);
 					}
 				}
 
 			} else {
 
 				if (op->arguments[0]) {
-					if (!_guess_expression_type(context,op->arguments[0],p_line,p1)) {
+					if (!_guess_expression_type(context, op->arguments[0], p_line, p1)) {
 
 						return false;
 					}
-
 				}
 
-				if (p1.value.get_type()==Variant::OBJECT) {
+				if (p1.value.get_type() == Variant::OBJECT) {
 					//??
-				} else if (p1.value.get_type()!=Variant::NIL) {
+				} else if (p1.value.get_type() != Variant::NIL) {
 
 					bool valid;
-					Variant ret = p1.value.get(p2.value,&valid);
+					Variant ret = p1.value.get(p2.value, &valid);
 					if (valid) {
-						r_type=_get_type_from_variant(ret);
+						r_type = _get_type_from_variant(ret);
 						return true;
 					}
 
 				} else {
-					if (p1.type!=Variant::NIL) {
+					if (p1.type != Variant::NIL) {
 						Variant::CallError ce;
-						Variant base = Variant::construct(p1.type,NULL,0,ce);
+						Variant base = Variant::construct(p1.type, NULL, 0, ce);
 						bool valid;
-						Variant ret = base.get(p2.value,&valid);
+						Variant ret = base.get(p2.value, &valid);
 						if (valid) {
-							r_type=_get_type_from_variant(ret);
+							r_type = _get_type_from_variant(ret);
 							return true;
 						}
 					}
@@ -873,127 +813,115 @@ static bool _guess_expression_type(GDCompletionContext& context,const GDParser::
 
 		} else {
 
-
 			Variant::Operator vop = Variant::OP_MAX;
-			switch(op->op) {
-				case GDParser::OperatorNode::OP_ADD: vop=Variant::OP_ADD; break;
-				case GDParser::OperatorNode::OP_SUB: vop=Variant::OP_SUBSTRACT; break;
-				case GDParser::OperatorNode::OP_MUL: vop=Variant::OP_MULTIPLY; break;
-				case GDParser::OperatorNode::OP_DIV: vop=Variant::OP_DIVIDE; break;
-				case GDParser::OperatorNode::OP_MOD: vop=Variant::OP_MODULE; break;
-				case GDParser::OperatorNode::OP_SHIFT_LEFT: vop=Variant::OP_SHIFT_LEFT; break;
-				case GDParser::OperatorNode::OP_SHIFT_RIGHT: vop=Variant::OP_SHIFT_RIGHT; break;
-				case GDParser::OperatorNode::OP_BIT_AND: vop=Variant::OP_BIT_AND; break;
-				case GDParser::OperatorNode::OP_BIT_OR: vop=Variant::OP_BIT_OR; break;
-				case GDParser::OperatorNode::OP_BIT_XOR: vop=Variant::OP_BIT_XOR; break;
-				default:{}
-
+			switch (op->op) {
+				case GDParser::OperatorNode::OP_ADD: vop = Variant::OP_ADD; break;
+				case GDParser::OperatorNode::OP_SUB: vop = Variant::OP_SUBSTRACT; break;
+				case GDParser::OperatorNode::OP_MUL: vop = Variant::OP_MULTIPLY; break;
+				case GDParser::OperatorNode::OP_DIV: vop = Variant::OP_DIVIDE; break;
+				case GDParser::OperatorNode::OP_MOD: vop = Variant::OP_MODULE; break;
+				case GDParser::OperatorNode::OP_SHIFT_LEFT: vop = Variant::OP_SHIFT_LEFT; break;
+				case GDParser::OperatorNode::OP_SHIFT_RIGHT: vop = Variant::OP_SHIFT_RIGHT; break;
+				case GDParser::OperatorNode::OP_BIT_AND: vop = Variant::OP_BIT_AND; break;
+				case GDParser::OperatorNode::OP_BIT_OR: vop = Variant::OP_BIT_OR; break;
+				case GDParser::OperatorNode::OP_BIT_XOR: vop = Variant::OP_BIT_XOR; break;
+				default: {}
 			}
 
-
-
-			if (vop==Variant::OP_MAX)
+			if (vop == Variant::OP_MAX)
 				return false;
 
-
-
 			GDCompletionIdentifier p1;
 			GDCompletionIdentifier p2;
 
 			if (op->arguments[0]) {
-				if (!_guess_expression_type(context,op->arguments[0],p_line,p1)) {
+				if (!_guess_expression_type(context, op->arguments[0], p_line, p1)) {
 
 					return false;
 				}
-
 			}
 
-			if (op->arguments.size()>1) {
-				if (!_guess_expression_type(context,op->arguments[1],p_line,p2)) {
+			if (op->arguments.size() > 1) {
+				if (!_guess_expression_type(context, op->arguments[1], p_line, p2)) {
 
 					return false;
 				}
 			}
 
 			Variant::CallError ce;
-			bool v1_use_value = p1.value.get_type()!=Variant::NIL && p1.value.get_type()!=Variant::OBJECT;
-			Variant v1 = (v1_use_value)?p1.value:Variant::construct(p1.type,NULL,0,ce);
-			bool v2_use_value = p2.value.get_type()!=Variant::NIL && p2.value.get_type()!=Variant::OBJECT;
-			Variant v2 = (v2_use_value)?p2.value:Variant::construct(p2.type,NULL,0,ce);
+			bool v1_use_value = p1.value.get_type() != Variant::NIL && p1.value.get_type() != Variant::OBJECT;
+			Variant v1 = (v1_use_value) ? p1.value : Variant::construct(p1.type, NULL, 0, ce);
+			bool v2_use_value = p2.value.get_type() != Variant::NIL && p2.value.get_type() != Variant::OBJECT;
+			Variant v2 = (v2_use_value) ? p2.value : Variant::construct(p2.type, NULL, 0, ce);
 			// avoid potential invalid ops
-			if ((vop==Variant::OP_DIVIDE || vop==Variant::OP_MODULE) && v2.get_type()==Variant::INT) {
-				v2=1;
-				v2_use_value=false;
+			if ((vop == Variant::OP_DIVIDE || vop == Variant::OP_MODULE) && v2.get_type() == Variant::INT) {
+				v2 = 1;
+				v2_use_value = false;
 			}
-			if (vop==Variant::OP_DIVIDE && v2.get_type()==Variant::REAL) {
-				v2=1.0;
-				v2_use_value=false;
+			if (vop == Variant::OP_DIVIDE && v2.get_type() == Variant::REAL) {
+				v2 = 1.0;
+				v2_use_value = false;
 			}
 
 			Variant r;
 			bool valid;
-			Variant::evaluate(vop,v1,v2,r,valid);
+			Variant::evaluate(vop, v1, v2, r, valid);
 			if (!valid)
 				return false;
-			r_type.type=r.get_type();
+			r_type.type = r.get_type();
 			if (v1_use_value && v2_use_value)
-				r_type.value=r;
+				r_type.value = r;
 
 			return true;
-
 		}
-
 	}
 
 	return false;
 }
 
-
-static bool _guess_identifier_type_in_block(GDCompletionContext& context,int p_line,const StringName& p_identifier,GDCompletionIdentifier &r_type) {
-
+static bool _guess_identifier_type_in_block(GDCompletionContext &context, int p_line, const StringName &p_identifier, GDCompletionIdentifier &r_type) {
 
 	GDCompletionIdentifier gdi = _get_native_class(context);
-	if (gdi.obj_type!=StringName()) {
+	if (gdi.obj_type != StringName()) {
 		bool valid;
-		Variant::Type t = ClassDB::get_property_type(gdi.obj_type,p_identifier,&valid);
-		if (t!=Variant::NIL && valid) {
-			r_type.type=t;
+		Variant::Type t = ClassDB::get_property_type(gdi.obj_type, p_identifier, &valid);
+		if (t != Variant::NIL && valid) {
+			r_type.type = t;
 			return true;
 		}
 	}
 
-	const GDParser::Node *last_assign=NULL;
-	int last_assign_line=-1;
+	const GDParser::Node *last_assign = NULL;
+	int last_assign_line = -1;
 
-	for (int i=0;i<context.block->statements.size();i++) {
+	for (int i = 0; i < context.block->statements.size(); i++) {
 
-		if (context.block->statements[i]->line>p_line)
+		if (context.block->statements[i]->line > p_line)
 			continue;
 
+		if (context.block->statements[i]->type == GDParser::BlockNode::TYPE_LOCAL_VAR) {
 
-		if (context.block->statements[i]->type==GDParser::BlockNode::TYPE_LOCAL_VAR) {
-
-			const GDParser::LocalVarNode *lv=static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]);
+			const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]);
 
-			if (lv->assign && lv->name==p_identifier) {
+			if (lv->assign && lv->name == p_identifier) {
 
-				last_assign=lv->assign;
-				last_assign_line=context.block->statements[i]->line;
+				last_assign = lv->assign;
+				last_assign_line = context.block->statements[i]->line;
 			}
 		}
 
-		if (context.block->statements[i]->type==GDParser::BlockNode::TYPE_OPERATOR) {
+		if (context.block->statements[i]->type == GDParser::BlockNode::TYPE_OPERATOR) {
 			const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(context.block->statements[i]);
-			if (op->op==GDParser::OperatorNode::OP_ASSIGN) {
+			if (op->op == GDParser::OperatorNode::OP_ASSIGN) {
 
-				if (op->arguments.size() && op->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) {
+				if (op->arguments.size() && op->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) {
 
 					const GDParser::IdentifierNode *id = static_cast<const GDParser::IdentifierNode *>(op->arguments[0]);
 
-					if (id->name==p_identifier) {
+					if (id->name == p_identifier) {
 
-						last_assign=op->arguments[1];
-						last_assign_line=context.block->statements[i]->line;
+						last_assign = op->arguments[1];
+						last_assign_line = context.block->statements[i]->line;
 					}
 				}
 			}
@@ -1003,20 +931,18 @@ static bool _guess_identifier_type_in_block(GDCompletionContext& context,int p_l
 	//use the last assignment, (then backwards?)
 	if (last_assign) {
 
-		return _guess_expression_type(context,last_assign,last_assign_line,r_type);
+		return _guess_expression_type(context, last_assign, last_assign_line, r_type);
 	}
 
-
 	return false;
 }
 
+static bool _guess_identifier_from_assignment_in_function(GDCompletionContext &context, int p_src_line, const StringName &p_identifier, const StringName &p_function, GDCompletionIdentifier &r_type) {
 
-static bool _guess_identifier_from_assignment_in_function(GDCompletionContext& context, int p_src_line, const StringName& p_identifier, const StringName& p_function,GDCompletionIdentifier &r_type) {
-
-	const GDParser::FunctionNode* func=NULL;
-	for(int i=0;i<context._class->functions.size();i++) {
-		if (context._class->functions[i]->name==p_function) {
-			func=context._class->functions[i];
+	const GDParser::FunctionNode *func = NULL;
+	for (int i = 0; i < context._class->functions.size(); i++) {
+		if (context._class->functions[i]->name == p_function) {
+			func = context._class->functions[i];
 			break;
 		}
 	}
@@ -1024,23 +950,23 @@ static bool _guess_identifier_from_assignment_in_function(GDCompletionContext& c
 	if (!func)
 		return false;
 
-	for(int i=0;i<func->body->statements.size();i++) {
+	for (int i = 0; i < func->body->statements.size(); i++) {
 
 		if (func->body->statements[i]->line == p_src_line) {
 			break;
 		}
 
-		if (func->body->statements[i]->type==GDParser::BlockNode::TYPE_OPERATOR) {
+		if (func->body->statements[i]->type == GDParser::BlockNode::TYPE_OPERATOR) {
 			const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(func->body->statements[i]);
-			if (op->op==GDParser::OperatorNode::OP_ASSIGN) {
+			if (op->op == GDParser::OperatorNode::OP_ASSIGN) {
 
-				if (op->arguments.size() && op->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) {
+				if (op->arguments.size() && op->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) {
 
 					const GDParser::IdentifierNode *id = static_cast<const GDParser::IdentifierNode *>(op->arguments[0]);
 
-					if (id->name==p_identifier) {
+					if (id->name == p_identifier) {
 
-						return _guess_expression_type(context,op->arguments[1],func->body->statements[i]->line,r_type);
+						return _guess_expression_type(context, op->arguments[1], func->body->statements[i]->line, r_type);
 					}
 				}
 			}
@@ -1050,66 +976,62 @@ static bool _guess_identifier_from_assignment_in_function(GDCompletionContext& c
 	return false;
 }
 
-static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const StringName& p_identifier,GDCompletionIdentifier &r_type) {
+static bool _guess_identifier_type(GDCompletionContext &context, int p_line, const StringName &p_identifier, GDCompletionIdentifier &r_type) {
 
 	//go to block first
 
+	const GDParser::BlockNode *block = context.block;
 
-	const GDParser::BlockNode *block=context.block;
-
-	while(block) {
+	while (block) {
 
 		GDCompletionContext c = context;
-		c.block=block;
+		c.block = block;
 
-		if (_guess_identifier_type_in_block(c,p_line,p_identifier,r_type)) {
+		if (_guess_identifier_type_in_block(c, p_line, p_identifier, r_type)) {
 			return true;
 		}
 
-		block=block->parent_block;
+		block = block->parent_block;
 	}
 
 	//guess from argument if virtual
-	if (context.function && context.function->name!=StringName()) {
+	if (context.function && context.function->name != StringName()) {
 
 		int argindex = -1;
 
-		for(int i=0;i<context.function->arguments.size();i++) {
+		for (int i = 0; i < context.function->arguments.size(); i++) {
 
-			if (context.function->arguments[i]==p_identifier) {
-				argindex=i;
+			if (context.function->arguments[i] == p_identifier) {
+				argindex = i;
 				break;
 			}
-
 		}
 
-		if (argindex!=-1) {
-			GDCompletionIdentifier id =_get_native_class(context);
-			if (id.type==Variant::OBJECT && id.obj_type!=StringName()) {
+		if (argindex != -1) {
+			GDCompletionIdentifier id = _get_native_class(context);
+			if (id.type == Variant::OBJECT && id.obj_type != StringName()) {
 				//this kinda sucks but meh
 
 				List<MethodInfo> vmethods;
-				ClassDB::get_virtual_methods(id.obj_type,&vmethods);
-				for (List<MethodInfo>::Element *E=vmethods.front();E;E=E->next()) {
-
+				ClassDB::get_virtual_methods(id.obj_type, &vmethods);
+				for (List<MethodInfo>::Element *E = vmethods.front(); E; E = E->next()) {
 
-					if (E->get().name==context.function->name && argindex<E->get().arguments.size()) {
+					if (E->get().name == context.function->name && argindex < E->get().arguments.size()) {
 
-						PropertyInfo arg=E->get().arguments[argindex];
+						PropertyInfo arg = E->get().arguments[argindex];
 
 						int scp = arg.name.find(":");
-						if (scp!=-1) {
+						if (scp != -1) {
 
-
-							r_type.type=Variant::OBJECT;
-							r_type.obj_type=arg.name.substr(scp+1,arg.name.length());
+							r_type.type = Variant::OBJECT;
+							r_type.obj_type = arg.name.substr(scp + 1, arg.name.length());
 							return true;
 
 						} else {
 
-							r_type.type=arg.type;
-							if (arg.hint==PROPERTY_HINT_RESOURCE_TYPE)
-								r_type.obj_type=arg.hint_string;
+							r_type.type = arg.type;
+							if (arg.hint == PROPERTY_HINT_RESOURCE_TYPE)
+								r_type.obj_type = arg.hint_string;
 							return true;
 						}
 					}
@@ -1120,40 +1042,40 @@ static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const
 
 	//guess type in constant
 
-	for(int i=0;i<context._class->constant_expressions.size();i++) {
+	for (int i = 0; i < context._class->constant_expressions.size(); i++) {
 
-		if (context._class->constant_expressions[i].identifier==p_identifier) {
+		if (context._class->constant_expressions[i].identifier == p_identifier) {
 
-			ERR_FAIL_COND_V( context._class->constant_expressions[i].expression->type!=GDParser::Node::TYPE_CONSTANT, false );
-			r_type=_get_type_from_variant(static_cast<const GDParser::ConstantNode*>(context._class->constant_expressions[i].expression)->value );
+			ERR_FAIL_COND_V(context._class->constant_expressions[i].expression->type != GDParser::Node::TYPE_CONSTANT, false);
+			r_type = _get_type_from_variant(static_cast<const GDParser::ConstantNode *>(context._class->constant_expressions[i].expression)->value);
 			return true;
 		}
 	}
 
 	if (!(context.function && context.function->_static)) {
 
-		for(int i=0;i<context._class->variables.size();i++) {
+		for (int i = 0; i < context._class->variables.size(); i++) {
 
-			if (context._class->variables[i].identifier==p_identifier) {
+			if (context._class->variables[i].identifier == p_identifier) {
 
-				if (context._class->variables[i]._export.type!=Variant::NIL) {
+				if (context._class->variables[i]._export.type != Variant::NIL) {
 
-					r_type=_get_type_from_pinfo(context._class->variables[i]._export);
+					r_type = _get_type_from_pinfo(context._class->variables[i]._export);
 					return true;
 				} else if (context._class->variables[i].expression) {
 
-					bool rtype = _guess_expression_type(context,context._class->variables[i].expression,context._class->variables[i].line,r_type);
-					if (rtype && r_type.type!=Variant::NIL)
+					bool rtype = _guess_expression_type(context, context._class->variables[i].expression, context._class->variables[i].line, r_type);
+					if (rtype && r_type.type != Variant::NIL)
 						return true;
 					//return _guess_expression_type(context,context._class->variables[i].expression,context._class->variables[i].line,r_type);
 				}
 
 				//try to guess from assignment in construtor or _ready
-				if (_guess_identifier_from_assignment_in_function(context,p_line+1,p_identifier,"_ready",r_type))
+				if (_guess_identifier_from_assignment_in_function(context, p_line + 1, p_identifier, "_ready", r_type))
 					return true;
-				if (_guess_identifier_from_assignment_in_function(context,p_line+1,p_identifier,"_enter_tree",r_type))
+				if (_guess_identifier_from_assignment_in_function(context, p_line + 1, p_identifier, "_enter_tree", r_type))
 					return true;
-				if (_guess_identifier_from_assignment_in_function(context,p_line+1,p_identifier,"_init",r_type))
+				if (_guess_identifier_from_assignment_in_function(context, p_line + 1, p_identifier, "_init", r_type))
 					return true;
 
 				return false;
@@ -1165,115 +1087,107 @@ static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const
 	List<PropertyInfo> props;
 	GlobalConfig::get_singleton()->get_property_list(&props);
 
-	for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 
 		String s = E->get().name;
 		if (!s.begins_with("autoload/"))
 			continue;
-		String name = s.get_slice("/",1);
-		if (name==String(p_identifier)) {
+		String name = s.get_slice("/", 1);
+		if (name == String(p_identifier)) {
 
 			String path = GlobalConfig::get_singleton()->get(s);
 			if (path.begins_with("*")) {
-				String script =path.substr(1,path.length());
+				String script = path.substr(1, path.length());
 
 				if (!script.ends_with(".gd")) {
 					//not a script, try find the script anyway,
 					//may have some success
-					script=script.get_basename()+".gd";
+					script = script.get_basename() + ".gd";
 				}
 
 				if (FileAccess::exists(script)) {
 
 					//print_line("is a script");
 
-
 					Ref<Script> scr;
 					if (ScriptCodeCompletionCache::get_sigleton())
 						scr = ScriptCodeCompletionCache::get_sigleton()->get_cached_resource(script);
 					else
 						scr = ResourceLoader::load(script);
 
-
-					r_type.obj_type="Node";
-					r_type.type=Variant::OBJECT;
-					r_type.script=scr;
-					r_type.value=Variant();
+					r_type.obj_type = "Node";
+					r_type.type = Variant::OBJECT;
+					r_type.script = scr;
+					r_type.value = Variant();
 
 					return true;
-
 				}
 			}
 		}
-
 	}
 
 	//global
-	for(Map<StringName,int>::Element *E=GDScriptLanguage::get_singleton()->get_global_map().front();E;E=E->next()) {
-		if (E->key()==p_identifier) {
+	for (Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) {
+		if (E->key() == p_identifier) {
 
-			r_type=_get_type_from_variant(GDScriptLanguage::get_singleton()->get_global_array()[E->get()]);
+			r_type = _get_type_from_variant(GDScriptLanguage::get_singleton()->get_global_array()[E->get()]);
 			return true;
 		}
-
 	}
 	return false;
 }
 
-
-static void _find_identifiers_in_block(GDCompletionContext& context,int p_line,bool p_only_functions,Set<String>& result) {
+static void _find_identifiers_in_block(GDCompletionContext &context, int p_line, bool p_only_functions, Set<String> &result) {
 
 	if (p_only_functions)
 		return;
 
-	for (int i=0;i<context.block->statements.size();i++) {
+	for (int i = 0; i < context.block->statements.size(); i++) {
 
-		if (context.block->statements[i]->line>p_line)
+		if (context.block->statements[i]->line > p_line)
 			continue;
 
+		if (context.block->statements[i]->type == GDParser::BlockNode::TYPE_LOCAL_VAR) {
 
-		if (context.block->statements[i]->type==GDParser::BlockNode::TYPE_LOCAL_VAR) {
-
-			const GDParser::LocalVarNode *lv=static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]);
+			const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]);
 			result.insert(lv->name.operator String());
 		}
 	}
 }
 
-static void _find_identifiers_in_class(GDCompletionContext& context,bool p_static,bool p_only_functions,Set<String>& result) {
+static void _find_identifiers_in_class(GDCompletionContext &context, bool p_static, bool p_only_functions, Set<String> &result) {
 
 	if (!p_static && !p_only_functions) {
 
-		for(int i=0;i<context._class->variables.size();i++) {
+		for (int i = 0; i < context._class->variables.size(); i++) {
 			result.insert(context._class->variables[i].identifier);
 		}
 	}
 	if (!p_only_functions) {
 
-		for(int i=0;i<context._class->constant_expressions.size();i++) {
+		for (int i = 0; i < context._class->constant_expressions.size(); i++) {
 			result.insert(context._class->constant_expressions[i].identifier);
 		}
 
-		for(int i=0;i<context._class->subclasses.size();i++) {
+		for (int i = 0; i < context._class->subclasses.size(); i++) {
 			result.insert(context._class->subclasses[i]->name);
 		}
-
 	}
 
-	for(int i=0;i<context._class->static_functions.size();i++) {
+	for (int i = 0; i < context._class->static_functions.size(); i++) {
 		if (context._class->static_functions[i]->arguments.size())
-			result.insert(context._class->static_functions[i]->name.operator String()+"(");
+			result.insert(context._class->static_functions[i]->name.operator String() + "(");
 		else
-			result.insert(context._class->static_functions[i]->name.operator String()+"()");
+			result.insert(context._class->static_functions[i]->name.operator String() + "()");
 	}
 
 	if (!p_static) {
 
-		for(int i=0;i<context._class->functions.size();i++) {
+		for (int i = 0; i < context._class->functions.size(); i++) {
 			if (context._class->functions[i]->arguments.size())
-				result.insert(context._class->functions[i]->name.operator String()+"(");
+				result.insert(context._class->functions[i]->name.operator String() + "(");
 			else
-				result.insert(context._class->functions[i]->name.operator String()+"()");
+				result.insert(context._class->functions[i]->name.operator String() + "()");
 		}
 	}
 
@@ -1281,135 +1195,130 @@ static void _find_identifiers_in_class(GDCompletionContext& context,bool p_stati
 
 	Ref<Reference> base = _get_parent_class(context);
 
-	while(true) {
+	while (true) {
 
 		Ref<GDScript> script = base;
 		Ref<GDNativeClass> nc = base;
 		if (script.is_valid()) {
 
 			if (!p_static && !p_only_functions) {
-				for (const Set<StringName>::Element *E=script->get_members().front();E;E=E->next()) {
+				for (const Set<StringName>::Element *E = script->get_members().front(); E; E = E->next()) {
 					result.insert(E->get().operator String());
 				}
 			}
 
 			if (!p_only_functions) {
-				for (const Map<StringName,Variant>::Element *E=script->get_constants().front();E;E=E->next()) {
+				for (const Map<StringName, Variant>::Element *E = script->get_constants().front(); E; E = E->next()) {
 					result.insert(E->key().operator String());
 				}
 			}
 
-			for (const Map<StringName,GDFunction*>::Element *E=script->get_member_functions().front();E;E=E->next()) {
+			for (const Map<StringName, GDFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) {
 				if (!p_static || E->get()->is_static()) {
 					if (E->get()->get_argument_count())
-						result.insert(E->key().operator String()+"(");
+						result.insert(E->key().operator String() + "(");
 					else
-						result.insert(E->key().operator String()+"()");
+						result.insert(E->key().operator String() + "()");
 				}
 			}
 
-			if (!p_only_functions)	{
-				for (const Map<StringName,Ref<GDScript> >::Element *E=script->get_subclasses().front();E;E=E->next()) {
+			if (!p_only_functions) {
+				for (const Map<StringName, Ref<GDScript> >::Element *E = script->get_subclasses().front(); E; E = E->next()) {
 					result.insert(E->key().operator String());
 				}
 			}
 
-			base=script->get_base();
+			base = script->get_base();
 			if (base.is_null())
-				base=script->get_native();
+				base = script->get_native();
 		} else if (nc.is_valid()) {
 
 			StringName type = nc->get_name();
 
 			if (!p_only_functions) {
 
-
 				List<String> constants;
-				ClassDB::get_integer_constant_list(type,&constants);
-				for(List<String>::Element *E=constants.front();E;E=E->next()) {
+				ClassDB::get_integer_constant_list(type, &constants);
+				for (List<String>::Element *E = constants.front(); E; E = E->next()) {
 					result.insert(E->get());
 				}
 
 				List<PropertyInfo> pinfo;
 
-				ClassDB::get_property_list(type,&pinfo);
+				ClassDB::get_property_list(type, &pinfo);
 
-				for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
-					if (E->get().usage&(PROPERTY_USAGE_GROUP|PROPERTY_USAGE_CATEGORY))
+				for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+					if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY))
 						continue;
-					if (E->get().name.find("/")!=-1)
+					if (E->get().name.find("/") != -1)
 						continue;
 					result.insert(E->get().name);
 				}
-
 			}
 			List<MethodInfo> methods;
-			ClassDB::get_method_list(type,&methods);
-			for(List<MethodInfo>::Element *E=methods.front();E;E=E->next()) {
+			ClassDB::get_method_list(type, &methods);
+			for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
 				if (E->get().name.begins_with("_"))
 					continue;
 				if (E->get().arguments.size())
-					result.insert(E->get().name+"(");
+					result.insert(E->get().name + "(");
 				else
-					result.insert(E->get().name+"()");
+					result.insert(E->get().name + "()");
 			}
 
-
-
 			break;
 		} else
 			break;
-
 	}
-
 }
 
-static void _find_identifiers(GDCompletionContext& context,int p_line,bool p_only_functions,Set<String>& result) {
+static void _find_identifiers(GDCompletionContext &context, int p_line, bool p_only_functions, Set<String> &result) {
 
-	const GDParser::BlockNode *block=context.block;
+	const GDParser::BlockNode *block = context.block;
 
 	if (context.function) {
 
-		const GDParser::FunctionNode* f = context.function;
+		const GDParser::FunctionNode *f = context.function;
 
-		for (int i=0;i<f->arguments.size();i++) {
+		for (int i = 0; i < f->arguments.size(); i++) {
 			result.insert(f->arguments[i].operator String());
 		}
 	}
 
-	while(block) {
+	while (block) {
 
 		GDCompletionContext c = context;
-		c.block=block;
+		c.block = block;
 
-		_find_identifiers_in_block(c,p_line,p_only_functions,result);
-		block=block->parent_block;
+		_find_identifiers_in_block(c, p_line, p_only_functions, result);
+		block = block->parent_block;
 	}
 
-	const GDParser::ClassNode *clss=context._class;
+	const GDParser::ClassNode *clss = context._class;
 
-	bool _static=context.function && context.function->_static;
+	bool _static = context.function && context.function->_static;
 
-	while(clss) {
+	while (clss) {
 		GDCompletionContext c = context;
-		c._class=clss;
-		c.block=NULL;
-		c.function=NULL;
-		_find_identifiers_in_class(c,_static,p_only_functions,result);
-		clss=clss->owner;
+		c._class = clss;
+		c.block = NULL;
+		c.function = NULL;
+		_find_identifiers_in_class(c, _static, p_only_functions, result);
+		clss = clss->owner;
 	}
 
-	for(int i=0;i<GDFunctions::FUNC_MAX;i++) {
+	for (int i = 0; i < GDFunctions::FUNC_MAX; i++) {
 
 		result.insert(GDFunctions::get_func_name(GDFunctions::Function(i)));
 	}
 
-	static const char*_type_names[Variant::VARIANT_MAX]={
-		"null","bool","int","float","String","Vector2","Rect2","Vector3","Transform2D","Plane","Quat","AABB","Basis","Transform",
-		"Color","Image","NodePath","RID","Object","InputEvent","Dictionary","Array","RawArray","IntArray","FloatArray","StringArray",
-		"Vector2Array","Vector3Array","ColorArray"};
+	static const char *_type_names[Variant::VARIANT_MAX] = {
+		"null", "bool", "int", "float", "String", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform",
+		"Color", "Image", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray",
+		"Vector2Array", "Vector3Array", "ColorArray"
+	};
 
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 		result.insert(_type_names[i]);
 	}
 
@@ -1417,37 +1326,34 @@ static void _find_identifiers(GDCompletionContext& context,int p_line,bool p_onl
 	List<PropertyInfo> props;
 	GlobalConfig::get_singleton()->get_property_list(&props);
 
-	for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 
 		String s = E->get().name;
 		if (!s.begins_with("autoload/"))
 			continue;
-		String name = s.get_slice("/",1);
+		String name = s.get_slice("/", 1);
 		String path = GlobalConfig::get_singleton()->get(s);
 		if (path.begins_with("*")) {
 			result.insert(name);
 		}
-
 	}
 
-
-	for(const Map<StringName,int>::Element *E=GDScriptLanguage::get_singleton()->get_global_map().front();E;E=E->next()) {
+	for (const Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) {
 		result.insert(E->key().operator String());
 	}
 }
 
-
-static String _get_visual_datatype(const PropertyInfo& p_info,bool p_isarg=true) {
+static String _get_visual_datatype(const PropertyInfo &p_info, bool p_isarg = true) {
 
 	String n = p_info.name;
 	int idx = n.find(":");
-	if (idx!=-1) {
-		return n.substr(idx+1,n.length());
+	if (idx != -1) {
+		return n.substr(idx + 1, n.length());
 	}
 
-	if (p_info.type==Variant::OBJECT && p_info.hint==PROPERTY_HINT_RESOURCE_TYPE)
+	if (p_info.type == Variant::OBJECT && p_info.hint == PROPERTY_HINT_RESOURCE_TYPE)
 		return p_info.hint_string;
-	if (p_info.type==Variant::NIL) {
+	if (p_info.type == Variant::NIL) {
 		if (p_isarg)
 			return "var";
 		else
@@ -1457,74 +1363,68 @@ static String _get_visual_datatype(const PropertyInfo& p_info,bool p_isarg=true)
 	return Variant::get_type_name(p_info.type);
 }
 
-static void _make_function_hint(const GDParser::FunctionNode* p_func,int p_argidx,String& arghint) {
+static void _make_function_hint(const GDParser::FunctionNode *p_func, int p_argidx, String &arghint) {
 
-	arghint="func "+p_func->name+"(";
-	for (int i=0;i<p_func->arguments.size();i++) {
-		if (i>0)
-			arghint+=", ";
+	arghint = "func " + p_func->name + "(";
+	for (int i = 0; i < p_func->arguments.size(); i++) {
+		if (i > 0)
+			arghint += ", ";
 		else
-			arghint+=" ";
+			arghint += " ";
 
-		if (i==p_argidx) {
-			arghint+=String::chr(0xFFFF);
+		if (i == p_argidx) {
+			arghint += String::chr(0xFFFF);
 		}
-		arghint+=p_func->arguments[i].operator String();
-		int deffrom = p_func->arguments.size()-p_func->default_values.size();
+		arghint += p_func->arguments[i].operator String();
+		int deffrom = p_func->arguments.size() - p_func->default_values.size();
 
-		if (i>=deffrom) {
-			int defidx = deffrom-i;
+		if (i >= deffrom) {
+			int defidx = deffrom - i;
 
-			if (defidx>=0 && defidx<p_func->default_values.size()) {
+			if (defidx >= 0 && defidx < p_func->default_values.size()) {
 
-				if (p_func->default_values[defidx]->type==GDParser::Node::TYPE_OPERATOR) {
-
-					const GDParser::OperatorNode *op=static_cast<const GDParser::OperatorNode *>(p_func->default_values[defidx]);
-					if (op->op==GDParser::OperatorNode::OP_ASSIGN) {
-						const GDParser::ConstantNode *cn=static_cast<const GDParser::ConstantNode *>(op->arguments[1]);
-						arghint+="="+cn->value.get_construct_string();
+				if (p_func->default_values[defidx]->type == GDParser::Node::TYPE_OPERATOR) {
 
+					const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(p_func->default_values[defidx]);
+					if (op->op == GDParser::OperatorNode::OP_ASSIGN) {
+						const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(op->arguments[1]);
+						arghint += "=" + cn->value.get_construct_string();
 					}
 				} else {
-
 				}
 			}
 		}
 
-		if (i==p_argidx) {
-			arghint+=String::chr(0xFFFF);
+		if (i == p_argidx) {
+			arghint += String::chr(0xFFFF);
 		}
 	}
-	if (p_func->arguments.size()>0)
-		arghint+=" ";
-	arghint+=")";
+	if (p_func->arguments.size() > 0)
+		arghint += " ";
+	arghint += ")";
 }
 
-
-static void _find_type_arguments(GDCompletionContext& context,const GDParser::Node*p_node,int p_line,const StringName& p_method,const GDCompletionIdentifier& id, int p_argidx, Set<String>& result, String& arghint) {
-
+static void _find_type_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, const StringName &p_method, const GDCompletionIdentifier &id, int p_argidx, Set<String> &result, String &arghint) {
 
 	//print_line("find type arguments?");
-	if (id.type==Variant::INPUT_EVENT && String(p_method)=="is_action" && p_argidx==0) {
+	if (id.type == Variant::INPUT_EVENT && String(p_method) == "is_action" && p_argidx == 0) {
 
 		List<PropertyInfo> pinfo;
 		GlobalConfig::get_singleton()->get_property_list(&pinfo);
 
-		for(List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
-			const PropertyInfo &pi=E->get();
+		for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+			const PropertyInfo &pi = E->get();
 
 			if (!pi.name.begins_with("input/"))
 				continue;
 
-			String name = pi.name.substr(pi.name.find("/")+1,pi.name.length());
-			result.insert("\""+name+"\"");
+			String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length());
+			result.insert("\"" + name + "\"");
 		}
 
+	} else if (id.type == Variant::OBJECT && id.obj_type != StringName()) {
 
-	} else if (id.type==Variant::OBJECT && id.obj_type!=StringName()) {
-
-
-		MethodBind *m = ClassDB::get_method(id.obj_type,p_method);
+		MethodBind *m = ClassDB::get_method(id.obj_type, p_method);
 		if (!m) {
 			//not in static method, see script
 
@@ -1532,51 +1432,49 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No
 			Ref<GDScript> on_script;
 
 			if (id.value.get_type()) {
-				Object *obj=id.value;
-
+				Object *obj = id.value;
 
 				if (obj) {
 
-
 					GDScript *scr = obj->cast_to<GDScript>();
 					if (scr) {
 						while (scr) {
 
-							for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) {
-								if (E->get()->is_static() && p_method==E->get()->get_name()) {
-									arghint="static func "+String(p_method)+"(";
-									for(int i=0;i<E->get()->get_argument_count();i++) {
-										if (i>0)
-											arghint+=", ";
+							for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) {
+								if (E->get()->is_static() && p_method == E->get()->get_name()) {
+									arghint = "static func " + String(p_method) + "(";
+									for (int i = 0; i < E->get()->get_argument_count(); i++) {
+										if (i > 0)
+											arghint += ", ";
 										else
-											arghint+=" ";
-										if (i==p_argidx) {
-											arghint+=String::chr(0xFFFF);
+											arghint += " ";
+										if (i == p_argidx) {
+											arghint += String::chr(0xFFFF);
 										}
-										arghint+="var "+E->get()->get_argument_name(i);
-										int deffrom = E->get()->get_argument_count()-E->get()->get_default_argument_count();
-										if (i>=deffrom) {
-											int defidx = deffrom-i;
-											if (defidx>=0 && defidx<E->get()->get_default_argument_count()) {
-												arghint+="="+E->get()->get_default_argument(defidx).get_construct_string();
+										arghint += "var " + E->get()->get_argument_name(i);
+										int deffrom = E->get()->get_argument_count() - E->get()->get_default_argument_count();
+										if (i >= deffrom) {
+											int defidx = deffrom - i;
+											if (defidx >= 0 && defidx < E->get()->get_default_argument_count()) {
+												arghint += "=" + E->get()->get_default_argument(defidx).get_construct_string();
 											}
 										}
-										if (i==p_argidx) {
-											arghint+=String::chr(0xFFFF);
+										if (i == p_argidx) {
+											arghint += String::chr(0xFFFF);
 										}
 									}
-									arghint+=")";
+									arghint += ")";
 									return; //found
 								}
 							}
 
 							if (scr->get_base().is_valid())
-								scr=scr->get_base().ptr();
+								scr = scr->get_base().ptr();
 							else
-								scr=NULL;
+								scr = NULL;
 						}
 					} else {
-						on_script=obj->get_script();
+						on_script = obj->get_script();
 					}
 				}
 			}
@@ -1584,7 +1482,7 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No
 			//print_line("but it has a script?");
 			if (!on_script.is_valid() && id.script.is_valid()) {
 				//print_line("yes");
-				on_script=id.script;
+				on_script = id.script;
 			}
 
 			if (on_script.is_valid()) {
@@ -1596,110 +1494,108 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No
 						String code = scr->get_source_code();
 						//print_line("has source code!");
 
-						if (code!="") {
+						if (code != "") {
 							//if there is code, parse it. This way is slower but updates in real-time
 							GDParser p;
 							//Error parse(const String& p_code, const String& p_base_path="", bool p_just_validate=false,const String& p_self_path="",bool p_for_completion=false);
 
-							Error err = p.parse(scr->get_source_code(),scr->get_path().get_base_dir(),true,"",false);
+							Error err = p.parse(scr->get_source_code(), scr->get_path().get_base_dir(), true, "", false);
 
-							if (err==OK) {
+							if (err == OK) {
 								//print_line("checking the functions...");
 								//only if ok, otherwise use what is cached on the script
 								//GDParser::ClassNode *base = p.
 								const GDParser::Node *root = p.get_parse_tree();
-								ERR_FAIL_COND(root->type!=GDParser::Node::TYPE_CLASS);
+								ERR_FAIL_COND(root->type != GDParser::Node::TYPE_CLASS);
 
-								const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode*>(root);
+								const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode *>(root);
 
-								const GDParser::FunctionNode* func=NULL;
-								bool st=false;
+								const GDParser::FunctionNode *func = NULL;
+								bool st = false;
 
-								for(int i=0;i<cl->functions.size();i++) {
+								for (int i = 0; i < cl->functions.size(); i++) {
 									//print_line(String(cl->functions[i]->name)+" vs "+String(p_method));
-									if (cl->functions[i]->name==p_method) {
-										func=cl->functions[i];
+									if (cl->functions[i]->name == p_method) {
+										func = cl->functions[i];
 									}
 								}
 
-								for(int i=0;i<cl->static_functions.size();i++) {
+								for (int i = 0; i < cl->static_functions.size(); i++) {
 
 									//print_line(String(cl->static_functions[i]->name)+" vs "+String(p_method));
-									if (cl->static_functions[i]->name==p_method) {
-										func=cl->static_functions[i];
-										st=true;
+									if (cl->static_functions[i]->name == p_method) {
+										func = cl->static_functions[i];
+										st = true;
 									}
-
 								}
 
 								if (func) {
 
-									arghint="func "+String(p_method)+"(";
+									arghint = "func " + String(p_method) + "(";
 									if (st)
-										arghint="static "+arghint;
-									for(int i=0;i<func->arguments.size();i++) {
-										if (i>0)
-											arghint+=", ";
+										arghint = "static " + arghint;
+									for (int i = 0; i < func->arguments.size(); i++) {
+										if (i > 0)
+											arghint += ", ";
 										else
-											arghint+=" ";
-										if (i==p_argidx) {
-											arghint+=String::chr(0xFFFF);
+											arghint += " ";
+										if (i == p_argidx) {
+											arghint += String::chr(0xFFFF);
 										}
-										arghint+="var "+String(func->arguments[i]);
-										int deffrom = func->arguments.size()-func->default_values.size();
-										if (i>=deffrom) {
+										arghint += "var " + String(func->arguments[i]);
+										int deffrom = func->arguments.size() - func->default_values.size();
+										if (i >= deffrom) {
 
-											int defidx = deffrom-i;
+											int defidx = deffrom - i;
 
-											if (defidx>=0 && defidx<func->default_values.size() && func->default_values[defidx]->type==GDParser::Node::TYPE_OPERATOR) {
-												const GDParser::OperatorNode *op=static_cast<const GDParser::OperatorNode *>(func->default_values[defidx]);
-												if (op->op==GDParser::OperatorNode::OP_ASSIGN) {
-													const GDParser::ConstantNode *cn=static_cast<const GDParser::ConstantNode *>(op->arguments[1]);
-													arghint+="="+cn->value.get_construct_string();
+											if (defidx >= 0 && defidx < func->default_values.size() && func->default_values[defidx]->type == GDParser::Node::TYPE_OPERATOR) {
+												const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(func->default_values[defidx]);
+												if (op->op == GDParser::OperatorNode::OP_ASSIGN) {
+													const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(op->arguments[1]);
+													arghint += "=" + cn->value.get_construct_string();
 												}
 											}
 										}
-										if (i==p_argidx) {
-											arghint+=String::chr(0xFFFF);
+										if (i == p_argidx) {
+											arghint += String::chr(0xFFFF);
 										}
 									}
 
-									arghint+=" )";
+									arghint += " )";
 									return;
 								}
 							} else {
 								//print_line("failed parsing?");
-								code="";
+								code = "";
 							}
-
 						}
 
-						if (code=="") {
+						if (code == "") {
 
-							for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) {
-								if (p_method==E->get()->get_name()) {
-									arghint="func "+String(p_method)+"(";
-									for(int i=0;i<E->get()->get_argument_count();i++) {
-										if (i>0)
-											arghint+=", ";
+							for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) {
+								if (p_method == E->get()->get_name()) {
+									arghint = "func " + String(p_method) + "(";
+									for (int i = 0; i < E->get()->get_argument_count(); i++) {
+										if (i > 0)
+											arghint += ", ";
 										else
-											arghint+=" ";
-										if (i==p_argidx) {
-											arghint+=String::chr(0xFFFF);
+											arghint += " ";
+										if (i == p_argidx) {
+											arghint += String::chr(0xFFFF);
 										}
-										arghint+="var "+E->get()->get_argument_name(i);
-										int deffrom = E->get()->get_argument_count()-E->get()->get_default_argument_count();
-										if (i>=deffrom) {
-											int defidx = deffrom-i;
-											if (defidx>=0 && defidx<E->get()->get_default_argument_count()) {
-												arghint+="="+E->get()->get_default_argument(defidx).get_construct_string();
+										arghint += "var " + E->get()->get_argument_name(i);
+										int deffrom = E->get()->get_argument_count() - E->get()->get_default_argument_count();
+										if (i >= deffrom) {
+											int defidx = deffrom - i;
+											if (defidx >= 0 && defidx < E->get()->get_default_argument_count()) {
+												arghint += "=" + E->get()->get_default_argument(defidx).get_construct_string();
 											}
 										}
-										if (i==p_argidx) {
-											arghint+=String::chr(0xFFFF);
+										if (i == p_argidx) {
+											arghint += String::chr(0xFFFF);
 										}
 									}
-									arghint+=")";
+									arghint += ")";
 									return; //found
 								}
 							}
@@ -1721,46 +1617,43 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No
 						}
 
 						if (scr->get_base().is_valid())
-							scr=scr->get_base().ptr();
+							scr = scr->get_base().ptr();
 						else
-							scr=NULL;
+							scr = NULL;
 					}
 				}
 			}
 
-
 		} else {
 			//regular method
 
-			if (p_method.operator String()=="connect") {
-
+			if (p_method.operator String() == "connect") {
 
-				if (p_argidx==0) {
+				if (p_argidx == 0) {
 					List<MethodInfo> sigs;
-					ClassDB::get_signal_list(id.obj_type,&sigs);
+					ClassDB::get_signal_list(id.obj_type, &sigs);
 
 					if (id.script.is_valid()) {
 						id.script->get_script_signal_list(&sigs);
-					} else if (id.value.get_type()==Variant::OBJECT) {
+					} else if (id.value.get_type() == Variant::OBJECT) {
 						Object *obj = id.value;
 						if (obj && !obj->get_script().is_null()) {
-							Ref<Script> scr=obj->get_script();
+							Ref<Script> scr = obj->get_script();
 							if (scr.is_valid()) {
 								scr->get_script_signal_list(&sigs);
 							}
 						}
 					}
 
-					for (List<MethodInfo>::Element *E=sigs.front();E;E=E->next()) {
-						result.insert("\""+E->get().name+"\"");
+					for (List<MethodInfo>::Element *E = sigs.front(); E; E = E->next()) {
+						result.insert("\"" + E->get().name + "\"");
 					}
 
-				} else if (p_argidx==2){
-
+				} else if (p_argidx == 2) {
 
 					if (context._class) {
-						for(int i=0;i<context._class->functions.size();i++) {
-							result.insert("\""+context._class->functions[i]->name+"\"");
+						for (int i = 0; i < context._class->functions.size(); i++) {
+							result.insert("\"" + context._class->functions[i]->name + "\"");
 						}
 					}
 				}
@@ -1773,173 +1666,163 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No
 				}*/
 			} else {
 
-				if (p_argidx==0 && (String(p_method)=="get_node" || String(p_method)=="has_node") && ClassDB::is_parent_class(id.obj_type,"Node")) {
+				if (p_argidx == 0 && (String(p_method) == "get_node" || String(p_method) == "has_node") && ClassDB::is_parent_class(id.obj_type, "Node")) {
 
 					List<PropertyInfo> props;
 					GlobalConfig::get_singleton()->get_property_list(&props);
 
-					for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+					for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 
 						String s = E->get().name;
 						if (!s.begins_with("autoload/"))
 							continue;
 						//print_line("found "+s);
-						String name = s.get_slice("/",1);
-						result.insert("\"/root/"+name+"\"");
+						String name = s.get_slice("/", 1);
+						result.insert("\"/root/" + name + "\"");
 					}
 				}
 
-				Object *obj=id.value;
+				Object *obj = id.value;
 				if (obj) {
 					List<String> options;
-					obj->get_argument_options(p_method,p_argidx,&options);
+					obj->get_argument_options(p_method, p_argidx, &options);
 
-					for(List<String>::Element *E=options.front();E;E=E->next()) {
+					for (List<String>::Element *E = options.front(); E; E = E->next()) {
 
 						result.insert(E->get());
 					}
 				}
-
 			}
 
-			arghint = _get_visual_datatype(m->get_argument_info(-1),false)+" "+p_method.operator String()+String("(");
+			arghint = _get_visual_datatype(m->get_argument_info(-1), false) + " " + p_method.operator String() + String("(");
 
-			for(int i=0;i<m->get_argument_count();i++) {
-				if (i>0)
-					arghint+=", ";
+			for (int i = 0; i < m->get_argument_count(); i++) {
+				if (i > 0)
+					arghint += ", ";
 				else
-					arghint+=" ";
+					arghint += " ";
 
-				if (i==p_argidx) {
-					arghint+=String::chr(0xFFFF);
+				if (i == p_argidx) {
+					arghint += String::chr(0xFFFF);
 				}
 				String n = m->get_argument_info(i).name;
 				int dp = n.find(":");
-				if (dp!=-1)
-					n=n.substr(0,dp);
-				arghint+=_get_visual_datatype(m->get_argument_info(i))+" "+n;
-				int deffrom = m->get_argument_count()-m->get_default_argument_count();
+				if (dp != -1)
+					n = n.substr(0, dp);
+				arghint += _get_visual_datatype(m->get_argument_info(i)) + " " + n;
+				int deffrom = m->get_argument_count() - m->get_default_argument_count();
 
+				if (i >= deffrom) {
+					int defidx = i - deffrom;
 
-				if (i>=deffrom) {
-					int defidx = i-deffrom;
-
-					if (defidx>=0 && defidx<m->get_default_argument_count()) {
-						Variant v= m->get_default_argument(i);
-						arghint+="="+v.get_construct_string();
+					if (defidx >= 0 && defidx < m->get_default_argument_count()) {
+						Variant v = m->get_default_argument(i);
+						arghint += "=" + v.get_construct_string();
 					}
 				}
 
-				if (i==p_argidx) {
-					arghint+=String::chr(0xFFFF);
+				if (i == p_argidx) {
+					arghint += String::chr(0xFFFF);
 				}
-
 			}
-			if (m->get_argument_count()>0)
-				arghint+=" ";
-
+			if (m->get_argument_count() > 0)
+				arghint += " ";
 
-			arghint+=")";
+			arghint += ")";
 		}
-
 	}
 }
 
+static void _find_call_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, int p_argidx, Set<String> &result, String &arghint) {
 
-static void _find_call_arguments(GDCompletionContext& context,const GDParser::Node* p_node, int p_line,int p_argidx, Set<String>& result, String& arghint) {
-
-
-
-	if (!p_node || p_node->type!=GDParser::Node::TYPE_OPERATOR) {
+	if (!p_node || p_node->type != GDParser::Node::TYPE_OPERATOR) {
 
 		return;
 	}
 
 	const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(p_node);
 
-	if (op->op!=GDParser::OperatorNode::OP_CALL) {
+	if (op->op != GDParser::OperatorNode::OP_CALL) {
 
 		return;
 	}
 
-	if (op->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
+	if (op->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
 		//complete built-in function
-		const GDParser::BuiltInFunctionNode *fn = static_cast<const GDParser::BuiltInFunctionNode*>(op->arguments[0]);
+		const GDParser::BuiltInFunctionNode *fn = static_cast<const GDParser::BuiltInFunctionNode *>(op->arguments[0]);
 		MethodInfo mi = GDFunctions::get_info(fn->function);
 
-		arghint = _get_visual_datatype(mi.return_val,false)+" "+GDFunctions::get_func_name(fn->function)+String("(");
-		for(int i=0;i<mi.arguments.size();i++) {
-			if (i>0)
-				arghint+=", ";
+		arghint = _get_visual_datatype(mi.return_val, false) + " " + GDFunctions::get_func_name(fn->function) + String("(");
+		for (int i = 0; i < mi.arguments.size(); i++) {
+			if (i > 0)
+				arghint += ", ";
 			else
-				arghint+=" ";
-			if (i==p_argidx) {
-				arghint+=String::chr(0xFFFF);
+				arghint += " ";
+			if (i == p_argidx) {
+				arghint += String::chr(0xFFFF);
 			}
-			arghint+=_get_visual_datatype(mi.arguments[i])+" "+mi.arguments[i].name;
-			if (i==p_argidx) {
-				arghint+=String::chr(0xFFFF);
+			arghint += _get_visual_datatype(mi.arguments[i]) + " " + mi.arguments[i].name;
+			if (i == p_argidx) {
+				arghint += String::chr(0xFFFF);
 			}
-
 		}
-		if (mi.arguments.size()>0)
-			arghint+=" ";
-		arghint+=")";
+		if (mi.arguments.size() > 0)
+			arghint += " ";
+		arghint += ")";
 
-	} else if (op->arguments[0]->type==GDParser::Node::TYPE_TYPE) {
+	} else if (op->arguments[0]->type == GDParser::Node::TYPE_TYPE) {
 		//complete constructor
-		const GDParser::TypeNode *tn = static_cast<const GDParser::TypeNode*>(op->arguments[0]);
+		const GDParser::TypeNode *tn = static_cast<const GDParser::TypeNode *>(op->arguments[0]);
 
 		List<MethodInfo> mil;
-		Variant::get_constructor_list(tn->vtype,&mil);
+		Variant::get_constructor_list(tn->vtype, &mil);
 
-		for(List<MethodInfo>::Element *E=mil.front();E;E=E->next()) {
+		for (List<MethodInfo>::Element *E = mil.front(); E; E = E->next()) {
 
 			MethodInfo mi = E->get();
-			if (mi.arguments.size()==0)
+			if (mi.arguments.size() == 0)
 				continue;
 			if (E->prev())
-				arghint+="\n";
-			arghint += Variant::get_type_name(tn->vtype)+" "+Variant::get_type_name(tn->vtype)+String("(");
-			for(int i=0;i<mi.arguments.size();i++) {
-				if (i>0)
-					arghint+=", ";
+				arghint += "\n";
+			arghint += Variant::get_type_name(tn->vtype) + " " + Variant::get_type_name(tn->vtype) + String("(");
+			for (int i = 0; i < mi.arguments.size(); i++) {
+				if (i > 0)
+					arghint += ", ";
 				else
-					arghint+=" ";
-				if (i==p_argidx) {
-					arghint+=String::chr(0xFFFF);
+					arghint += " ";
+				if (i == p_argidx) {
+					arghint += String::chr(0xFFFF);
 				}
-				arghint+=_get_visual_datatype(mi.arguments[i])+" "+mi.arguments[i].name;
-				if (i==p_argidx) {
-					arghint+=String::chr(0xFFFF);
+				arghint += _get_visual_datatype(mi.arguments[i]) + " " + mi.arguments[i].name;
+				if (i == p_argidx) {
+					arghint += String::chr(0xFFFF);
 				}
-
 			}
-			if (mi.arguments.size()>0)
-				arghint+=" ";
-			arghint+=")";
+			if (mi.arguments.size() > 0)
+				arghint += " ";
+			arghint += ")";
 		}
 
-	} else if (op->arguments.size()>=2 && op->arguments[1]->type==GDParser::Node::TYPE_IDENTIFIER) {
+	} else if (op->arguments.size() >= 2 && op->arguments[1]->type == GDParser::Node::TYPE_IDENTIFIER) {
 		//make sure identifier exists...
 
-		const GDParser::IdentifierNode *id=static_cast<const GDParser::IdentifierNode *>(op->arguments[1]);
+		const GDParser::IdentifierNode *id = static_cast<const GDParser::IdentifierNode *>(op->arguments[1]);
 
-		if (op->arguments[0]->type==GDParser::Node::TYPE_SELF) {
+		if (op->arguments[0]->type == GDParser::Node::TYPE_SELF) {
 			//self, look up
 
-			for(int i=0;i<context._class->static_functions.size();i++) {
-				if (context._class->static_functions[i]->name==id->name) {
-					_make_function_hint(context._class->static_functions[i],p_argidx,arghint);
+			for (int i = 0; i < context._class->static_functions.size(); i++) {
+				if (context._class->static_functions[i]->name == id->name) {
+					_make_function_hint(context._class->static_functions[i], p_argidx, arghint);
 					return;
 				}
 			}
 
 			if (context.function && !context.function->_static) {
 
-				for(int i=0;i<context._class->functions.size();i++) {
-					if (context._class->functions[i]->name==id->name) {
-						_make_function_hint(context._class->functions[i],p_argidx,arghint);
+				for (int i = 0; i < context._class->functions.size(); i++) {
+					if (context._class->functions[i]->name == id->name) {
+						_make_function_hint(context._class->functions[i], p_argidx, arghint);
 						return;
 					}
 				}
@@ -1947,64 +1830,61 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No
 
 			Ref<Reference> base = _get_parent_class(context);
 
-			while(true) {
+			while (true) {
 
 				Ref<GDScript> script = base;
 				Ref<GDNativeClass> nc = base;
 				if (script.is_valid()) {
 
+					for (const Map<StringName, GDFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) {
 
-					for (const Map<StringName,GDFunction*>::Element *E=script->get_member_functions().front();E;E=E->next()) {
-
-						if (E->key()==id->name) {
+						if (E->key() == id->name) {
 
 							if (context.function && context.function->_static && !E->get()->is_static())
 								continue;
 
-
-							arghint = "func "+id->name.operator String()+String("(");
-							for(int i=0;i<E->get()->get_argument_count();i++) {
-								if (i>0)
-									arghint+=", ";
+							arghint = "func " + id->name.operator String() + String("(");
+							for (int i = 0; i < E->get()->get_argument_count(); i++) {
+								if (i > 0)
+									arghint += ", ";
 								else
-									arghint+=" ";
-								if (i==p_argidx) {
-									arghint+=String::chr(0xFFFF);
+									arghint += " ";
+								if (i == p_argidx) {
+									arghint += String::chr(0xFFFF);
 								}
-								arghint+=E->get()->get_argument_name(i);
-								int deffrom = E->get()->get_argument_count()-E->get()->get_default_argument_count();
-								if (i>=deffrom) {
-									int defidx = deffrom-i;
-									if (defidx>=0 && defidx<E->get()->get_default_argument_count()) {
-										arghint+="="+E->get()->get_default_argument(defidx).get_construct_string();
+								arghint += E->get()->get_argument_name(i);
+								int deffrom = E->get()->get_argument_count() - E->get()->get_default_argument_count();
+								if (i >= deffrom) {
+									int defidx = deffrom - i;
+									if (defidx >= 0 && defidx < E->get()->get_default_argument_count()) {
+										arghint += "=" + E->get()->get_default_argument(defidx).get_construct_string();
 									}
 								}
-								if (i==p_argidx) {
-									arghint+=String::chr(0xFFFF);
+								if (i == p_argidx) {
+									arghint += String::chr(0xFFFF);
 								}
-
 							}
-							if (E->get()->get_argument_count()>0)
-								arghint+=" ";
-							arghint+=")";
+							if (E->get()->get_argument_count() > 0)
+								arghint += " ";
+							arghint += ")";
 							return;
 						}
 					}
 
-					base=script->get_base();
+					base = script->get_base();
 					if (base.is_null())
-						base=script->get_native();
+						base = script->get_native();
 				} else if (nc.is_valid()) {
 
 					if (context.function && !context.function->_static) {
 
 						GDCompletionIdentifier ci;
-						ci.type=Variant::OBJECT;
-						ci.obj_type=nc->get_name();
+						ci.type = Variant::OBJECT;
+						ci.obj_type = nc->get_name();
 						if (!context._class->owner)
-							ci.value=context.base;
+							ci.value = context.base;
 
-						_find_type_arguments(context,p_node,p_line,id->name,ci,p_argidx,result,arghint);
+						_find_type_arguments(context, p_node, p_line, id->name, ci, p_argidx, result, arghint);
 						//guess type..
 						/*
 						List<MethodInfo> methods;
@@ -2019,20 +1899,17 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No
 					break;
 				} else
 					break;
-
 			}
 		} else {
 			//indexed lookup
 
 			GDCompletionIdentifier ci;
-			if (_guess_expression_type(context,op->arguments[0],p_line,ci)) {
+			if (_guess_expression_type(context, op->arguments[0], p_line, ci)) {
 
-				_find_type_arguments(context,p_node,p_line,id->name,ci,p_argidx,result,arghint);
+				_find_type_arguments(context, p_node, p_line, id->name, ci, p_argidx, result, arghint);
 				return;
 			}
-
 		}
-
 	}
 #if 0
 	bool _static=context.function->_static;
@@ -2127,42 +2004,40 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No
 	}
 
 #endif
-
 }
 
-Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base_path, Object*p_owner, List<String>* r_options, String &r_call_hint) {
+Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, String &r_call_hint) {
 
 	GDParser p;
 
-	p.parse(p_code,p_base_path,false,"",true);
-	bool isfunction=false;
+	p.parse(p_code, p_base_path, false, "", true);
+	bool isfunction = false;
 	Set<String> options;
 
 	GDCompletionContext context;
-	context._class=p.get_completion_class();
-	context.block=p.get_completion_block();
-	context.function=p.get_completion_function();
-	context.base=p_owner;
-	context.base_path=p_base_path;
+	context._class = p.get_completion_class();
+	context.block = p.get_completion_block();
+	context.function = p.get_completion_function();
+	context.base = p_owner;
+	context.base_path = p_base_path;
 
-	switch(p.get_completion_type()) {
+	switch (p.get_completion_type()) {
 
 		case GDParser::COMPLETION_NONE: {
 		} break;
 		case GDParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
 			List<StringName> constants;
-			Variant::get_numeric_constants_for_type(p.get_completion_built_in_constant(),&constants);
-			for(List<StringName>::Element *E=constants.front();E;E=E->next()) {
+			Variant::get_numeric_constants_for_type(p.get_completion_built_in_constant(), &constants);
+			for (List<StringName>::Element *E = constants.front(); E; E = E->next()) {
 				options.insert(E->get().operator String());
 			}
 
-
 		} break;
 		case GDParser::COMPLETION_FUNCTION:
-			isfunction=true;
+			isfunction = true;
 		case GDParser::COMPLETION_IDENTIFIER: {
 
-			_find_identifiers(context,p.get_completion_line(),isfunction,options);
+			_find_identifiers(context, p.get_completion_line(), isfunction, options);
 		} break;
 		case GDParser::COMPLETION_PARENT_FUNCTION: {
 
@@ -2171,98 +2046,91 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base
 
 			if (p_owner) {
 				List<String> opts;
-				p_owner->get_argument_options("get_node",0,&opts);
+				p_owner->get_argument_options("get_node", 0, &opts);
 
-				for (List<String>::Element *E=opts.front();E;E=E->next()) {
+				for (List<String>::Element *E = opts.front(); E; E = E->next()) {
 
 					String opt = E->get().strip_edges();
 					if (opt.begins_with("\"") && opt.ends_with("\"")) {
-						String idopt=opt.substr(1,opt.length()-2);
-						if (idopt.replace("/","_").is_valid_identifier()) {
+						String idopt = opt.substr(1, opt.length() - 2);
+						if (idopt.replace("/", "_").is_valid_identifier()) {
 							options.insert(idopt);
 						} else {
 							options.insert(opt);
 						}
 					}
 				}
-
 			}
 		} break;
 		case GDParser::COMPLETION_METHOD:
-			isfunction=true;
+			isfunction = true;
 		case GDParser::COMPLETION_INDEX: {
 
 			const GDParser::Node *node = p.get_completion_node();
-			if (node->type!=GDParser::Node::TYPE_OPERATOR)
+			if (node->type != GDParser::Node::TYPE_OPERATOR)
 				break;
 
-
-
-
 			GDCompletionIdentifier t;
-			if (_guess_expression_type(context,static_cast<const GDParser::OperatorNode *>(node)->arguments[0],p.get_completion_line(),t)) {
+			if (_guess_expression_type(context, static_cast<const GDParser::OperatorNode *>(node)->arguments[0], p.get_completion_line(), t)) {
 
-				if (t.type==Variant::OBJECT && t.obj_type=="GDNativeClass") {
+				if (t.type == Variant::OBJECT && t.obj_type == "GDNativeClass") {
 					//native enum
 					Ref<GDNativeClass> gdn = t.value;
 					if (gdn.is_valid()) {
 						StringName cn = gdn->get_name();
 						List<String> cnames;
-						ClassDB::get_integer_constant_list(cn,&cnames);
-						for (List<String>::Element *E=cnames.front();E;E=E->next()) {
+						ClassDB::get_integer_constant_list(cn, &cnames);
+						for (List<String>::Element *E = cnames.front(); E; E = E->next()) {
 							options.insert(E->get());
 						}
 
 						List<PropertyInfo> pinfo;
-						ClassDB::get_property_list(cn,&pinfo);
+						ClassDB::get_property_list(cn, &pinfo);
 
-						for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
-							if (E->get().usage&(PROPERTY_USAGE_GROUP|PROPERTY_USAGE_CATEGORY))
+						for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+							if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY))
 								continue;
-							if (E->get().name.find("/")!=-1)
+							if (E->get().name.find("/") != -1)
 								continue;
 							options.insert(E->get().name);
 						}
 					}
-				} else if (t.type==Variant::OBJECT && t.obj_type!=StringName()) {
+				} else if (t.type == Variant::OBJECT && t.obj_type != StringName()) {
 
 					Ref<GDScript> on_script;
 
 					if (t.value.get_type()) {
-						Object *obj=t.value;
-
+						Object *obj = t.value;
 
 						if (obj) {
 
-
 							GDScript *scr = obj->cast_to<GDScript>();
 							if (scr) {
 								while (scr) {
 
 									if (!isfunction) {
-										for (const Map<StringName,Variant>::Element *E=scr->get_constants().front();E;E=E->next()) {
+										for (const Map<StringName, Variant>::Element *E = scr->get_constants().front(); E; E = E->next()) {
 											options.insert(E->key());
 										}
 									}
-									for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) {
+									for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) {
 										if (E->get()->is_static())
 											options.insert(E->key());
 									}
 
 									if (scr->get_base().is_valid())
-										scr=scr->get_base().ptr();
+										scr = scr->get_base().ptr();
 									else
-										scr=NULL;
+										scr = NULL;
 								}
 							} else {
-								on_script=obj->get_script();
+								on_script = obj->get_script();
 							}
 						}
 					}
 
-
 					if (!on_script.is_valid() && t.script.is_valid()) {
-						on_script=t.script;
+						on_script = t.script;
 					}
 
 					if (on_script.is_valid()) {
@@ -2273,132 +2141,119 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base
 
 								String code = scr->get_source_code();
 
-								if (code!="") {
+								if (code != "") {
 									//if there is code, parse it. This way is slower but updates in real-time
 									GDParser p;
 
-									Error err = p.parse(scr->get_source_code(),scr->get_path().get_base_dir(),true,"",false);
+									Error err = p.parse(scr->get_source_code(), scr->get_path().get_base_dir(), true, "", false);
 
-									if (err==OK) {
+									if (err == OK) {
 										//only if ok, otherwise use what is cached on the script
 										//GDParser::ClassNode *base = p.
 										const GDParser::Node *root = p.get_parse_tree();
-										ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,ERR_PARSE_ERROR);
+										ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, ERR_PARSE_ERROR);
 
-										const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode*>(root);
+										const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode *>(root);
 
-										for(int i=0;i<cl->functions.size();i++) {
+										for (int i = 0; i < cl->functions.size(); i++) {
 
 											if (cl->functions[i]->arguments.size())
-												options.insert(String(cl->functions[i]->name)+"(");
+												options.insert(String(cl->functions[i]->name) + "(");
 											else
-												options.insert(String(cl->functions[i]->name)+"()");
+												options.insert(String(cl->functions[i]->name) + "()");
 										}
 
-										for(int i=0;i<cl->static_functions.size();i++) {
+										for (int i = 0; i < cl->static_functions.size(); i++) {
 
 											if (cl->static_functions[i]->arguments.size())
-												options.insert(String(cl->static_functions[i]->name)+"(");
+												options.insert(String(cl->static_functions[i]->name) + "(");
 											else
-												options.insert(String(cl->static_functions[i]->name)+"()");
-
+												options.insert(String(cl->static_functions[i]->name) + "()");
 										}
 
 										if (!isfunction) {
-											for(int i=0;i<cl->variables.size();i++) {
+											for (int i = 0; i < cl->variables.size(); i++) {
 
 												options.insert(String(cl->variables[i].identifier));
 											}
 
-											for(int i=0;i<cl->constant_expressions.size();i++) {
+											for (int i = 0; i < cl->constant_expressions.size(); i++) {
 
 												options.insert(String(cl->constant_expressions[i].identifier));
 											}
-
 										}
 
-
 									} else {
-										code=""; //well, then no code
+										code = ""; //well, then no code
 									}
-
 								}
 
-								if (code=="") {
+								if (code == "") {
 									//use class directly, no code was found
 									if (!isfunction) {
-										for (const Map<StringName,Variant>::Element *E=scr->get_constants().front();E;E=E->next()) {
+										for (const Map<StringName, Variant>::Element *E = scr->get_constants().front(); E; E = E->next()) {
 											options.insert(E->key());
 										}
 									}
-									for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) {
+									for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) {
 										if (E->get()->get_argument_count())
-											options.insert(String(E->key())+"()");
+											options.insert(String(E->key()) + "()");
 										else
-											options.insert(String(E->key())+"(");
-
+											options.insert(String(E->key()) + "(");
 									}
 
-									for (const Set<StringName>::Element *E=scr->get_members().front();E;E=E->next()) {
+									for (const Set<StringName>::Element *E = scr->get_members().front(); E; E = E->next()) {
 										options.insert(E->get());
 									}
 								}
 
 								if (scr->get_base().is_valid())
-									scr=scr->get_base().ptr();
+									scr = scr->get_base().ptr();
 								else
-									scr=NULL;
+									scr = NULL;
 							}
 						}
 					}
 
-
-
-
-
-
 					if (!isfunction) {
-						ClassDB::get_integer_constant_list(t.obj_type,r_options);
+						ClassDB::get_integer_constant_list(t.obj_type, r_options);
 
 						List<PropertyInfo> pinfo;
-						ClassDB::get_property_list(t.obj_type,&pinfo);
+						ClassDB::get_property_list(t.obj_type, &pinfo);
 
-						for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
-							if (E->get().usage&(PROPERTY_USAGE_GROUP|PROPERTY_USAGE_CATEGORY))
+						for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+							if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY))
 								continue;
-							if (E->get().name.find("/")!=-1)
+							if (E->get().name.find("/") != -1)
 								continue;
 							r_options->push_back(E->get().name);
 						}
 					}
 
-
 					List<MethodInfo> mi;
-					ClassDB::get_method_list(t.obj_type,&mi);
-					for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) {
+					ClassDB::get_method_list(t.obj_type, &mi);
+					for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) {
 
 						if (E->get().name.begins_with("_"))
 							continue;
 
 						if (E->get().arguments.size())
-							options.insert(E->get().name+"(");
+							options.insert(E->get().name + "(");
 						else
-							options.insert(E->get().name+"()");
-
+							options.insert(E->get().name + "()");
 					}
 				} else {
 
-
-					if (t.type==Variant::INPUT_EVENT) {
+					if (t.type == Variant::INPUT_EVENT) {
 
 						//this is hardcoded otherwise it's not obvious
 						Set<String> exclude;
 
-						for(int i=0;i<InputEvent::TYPE_MAX;i++) {
+						for (int i = 0; i < InputEvent::TYPE_MAX; i++) {
 
 							InputEvent ie;
-							ie.type=InputEvent::Type(i);
-							static const char*evnames[]={
+							ie.type = InputEvent::Type(i);
+							static const char *evnames[] = {
 								"# Common",
 								"# Key",
 								"# MouseMotion",
@@ -2414,22 +2269,20 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base
 
 							Variant v = ie;
 
-							if (i==0) {
+							if (i == 0) {
 								List<MethodInfo> mi;
 								v.get_method_list(&mi);
-								for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) {
-									r_options->push_back(E->get().name+"(");
-
+								for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) {
+									r_options->push_back(E->get().name + "(");
 								}
-
 							}
 
 							List<PropertyInfo> pi;
 							v.get_property_list(&pi);
 
-							for (List<PropertyInfo>::Element *E=pi.front();E;E=E->next()) {
+							for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) {
 
-								if (i==0)
+								if (i == 0)
 									exclude.insert(E->get().name);
 								else if (exclude.has(E->get().name))
 									continue;
@@ -2439,67 +2292,64 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base
 						}
 						return OK;
 					} else {
-						if (t.value.get_type()==Variant::NIL) {
+						if (t.value.get_type() == Variant::NIL) {
 							Variant::CallError ce;
-							t.value=Variant::construct(t.type,NULL,0,ce);
+							t.value = Variant::construct(t.type, NULL, 0, ce);
 						}
 
-
 						if (!isfunction) {
 							List<PropertyInfo> pl;
 							t.value.get_property_list(&pl);
-							for (List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
+							for (List<PropertyInfo>::Element *E = pl.front(); E; E = E->next()) {
 
-								if (E->get().name.find("/")==-1)
+								if (E->get().name.find("/") == -1)
 									options.insert(E->get().name);
 							}
 						}
 
 						List<MethodInfo> mi;
 						t.value.get_method_list(&mi);
-						for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) {
+						for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) {
 							if (E->get().arguments.size())
-								options.insert(E->get().name+"(");
+								options.insert(E->get().name + "(");
 							else
-								options.insert(E->get().name+"()");
-
+								options.insert(E->get().name + "()");
 						}
 					}
 				}
 			}
 
-
 		} break;
 		case GDParser::COMPLETION_CALL_ARGUMENTS: {
 
-			_find_call_arguments(context,p.get_completion_node(),p.get_completion_line(),p.get_completion_argument_index(),options,r_call_hint);
+			_find_call_arguments(context, p.get_completion_node(), p.get_completion_line(), p.get_completion_argument_index(), options, r_call_hint);
 		} break;
 		case GDParser::COMPLETION_VIRTUAL_FUNC: {
 
 			GDCompletionIdentifier cid = _get_native_class(context);
 
-			if (cid.obj_type!=StringName()) {
+			if (cid.obj_type != StringName()) {
 				List<MethodInfo> vm;
-				ClassDB::get_virtual_methods(cid.obj_type,&vm);
-				for(List<MethodInfo>::Element *E=vm.front();E;E=E->next()) {
+				ClassDB::get_virtual_methods(cid.obj_type, &vm);
+				for (List<MethodInfo>::Element *E = vm.front(); E; E = E->next()) {
 
-					MethodInfo &mi=E->get();
+					MethodInfo &mi = E->get();
 					String m = mi.name;
-					if (m.find(":")!=-1)
-						m=m.substr(0,m.find(":"));
-					m+="(";
+					if (m.find(":") != -1)
+						m = m.substr(0, m.find(":"));
+					m += "(";
 
 					if (mi.arguments.size()) {
-						for(int i=0;i<mi.arguments.size();i++) {
-							if (i>0)
-								m+=", ";
-							String n =mi.arguments[i].name;
-							if (n.find(":")!=-1)
-								n=n.substr(0,n.find(":"));
-							m+=n;
+						for (int i = 0; i < mi.arguments.size(); i++) {
+							if (i > 0)
+								m += ", ";
+							String n = mi.arguments[i].name;
+							if (n.find(":") != -1)
+								n = n.substr(0, n.find(":"));
+							m += n;
 						}
 					}
-					m+="):";
+					m += "):";
 
 					options.insert(m);
 				}
@@ -2510,24 +2360,22 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base
 			const GDParser::Node *node = p.get_completion_node();
 
 			GDCompletionIdentifier t;
-			if (!_guess_expression_type(context,node,p.get_completion_line(),t))
+			if (!_guess_expression_type(context, node, p.get_completion_line(), t))
 				break;
 
-			if (t.type==Variant::OBJECT && t.obj_type!=StringName()) {
+			if (t.type == Variant::OBJECT && t.obj_type != StringName()) {
 
 				List<MethodInfo> sigs;
-				ClassDB::get_signal_list(t.obj_type,&sigs);
-				for (List<MethodInfo>::Element *E=sigs.front();E;E=E->next()) {
-					options.insert("\""+E->get().name+"\"");
+				ClassDB::get_signal_list(t.obj_type, &sigs);
+				for (List<MethodInfo>::Element *E = sigs.front(); E; E = E->next()) {
+					options.insert("\"" + E->get().name + "\"");
 				}
 			}
 
 		} break;
-
 	}
 
-
-	for(Set<String>::Element *E=options.front();E;E=E->next()) {
+	for (Set<String>::Element *E = options.front(); E; E = E->next()) {
 		r_options->push_back(E->get());
 	}
 
@@ -2536,25 +2384,23 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base
 
 #else
 
-Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base_path, Object*p_owner, List<String>* r_options, String &r_call_hint) {
+Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, String &r_call_hint) {
 	return OK;
 }
 
 #endif
 
-
-void GDScriptLanguage::auto_indent_code(String& p_code,int p_from_line,int p_to_line) const {
-
+void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
 
 	Vector<String> lines = p_code.split("\n");
 	List<int> indent_stack;
 
-	for(int i=0;i<lines.size();i++) {
+	for (int i = 0; i < lines.size(); i++) {
 
 		String l = lines[i];
-		int tc=0;
-		for(int j=0;j<l.length();j++) {
-			if (l[j]==' ' || l[j]=='\t') {
+		int tc = 0;
+		for (int j = 0; j < l.length(); j++) {
+			if (l[j] == ' ' || l[j] == '\t') {
 
 				tc++;
 			} else {
@@ -2562,252 +2408,237 @@ void GDScriptLanguage::auto_indent_code(String& p_code,int p_from_line,int p_to_
 			}
 		}
 
-
-		String st = l.substr(tc,l.length()).strip_edges();
-		if (st=="" || st.begins_with("#"))
+		String st = l.substr(tc, l.length()).strip_edges();
+		if (st == "" || st.begins_with("#"))
 			continue; //ignore!
 
-		int ilevel=0;
+		int ilevel = 0;
 		if (indent_stack.size()) {
-			ilevel=indent_stack.back()->get();
+			ilevel = indent_stack.back()->get();
 		}
 
-		if (tc>ilevel) {
+		if (tc > ilevel) {
 			indent_stack.push_back(tc);
-		} else if (tc<ilevel) {
-			while(indent_stack.size() && indent_stack.back()->get()>tc) {
+		} else if (tc < ilevel) {
+			while (indent_stack.size() && indent_stack.back()->get() > tc) {
 				indent_stack.pop_back();
 			}
 
-			if (indent_stack.size() && indent_stack.back()->get()!=tc)
+			if (indent_stack.size() && indent_stack.back()->get() != tc)
 				indent_stack.push_back(tc); //this is not right but gets the job done
 		}
 
-		if (i>=p_from_line) {
+		if (i >= p_from_line) {
 
-			l="";
-			for(int j=0;j<indent_stack.size();j++)
-				l+="\t";
-			l+=st;
+			l = "";
+			for (int j = 0; j < indent_stack.size(); j++)
+				l += "\t";
+			l += st;
 
-
-		} else if (i>p_to_line) {
+		} else if (i > p_to_line) {
 			break;
 		}
 
 		//print_line(itos(indent_stack.size())+","+itos(tc)+": "+l);
-		lines[i]=l;
+		lines[i] = l;
 	}
 
-	p_code="";
-	for(int i=0;i<lines.size();i++) {
-		if (i>0)
-			p_code+="\n";
-		p_code+=lines[i];
+	p_code = "";
+	for (int i = 0; i < lines.size(); i++) {
+		if (i > 0)
+			p_code += "\n";
+		p_code += lines[i];
 	}
-
 }
 
 #ifdef TOOLS_ENABLED
 
-Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol,const String& p_base_path, Object*p_owner,LookupResult& r_result) {
-
+Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_base_path, Object *p_owner, LookupResult &r_result) {
 
 	//before parsing, try the usual stuff
 	if (ClassDB::class_exists(p_symbol)) {
-		r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS;
-		r_result.class_name=p_symbol;
+		r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+		r_result.class_name = p_symbol;
 		return OK;
 	}
 
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 		Variant::Type t = Variant::Type(i);
-		if (Variant::get_type_name(t)==p_symbol) {
-			r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS;
-			r_result.class_name=Variant::get_type_name(t);
+		if (Variant::get_type_name(t) == p_symbol) {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+			r_result.class_name = Variant::get_type_name(t);
 			return OK;
 		}
 	}
 
-	for(int i=0;i<GDFunctions::FUNC_MAX;i++) {
-		if (GDFunctions::get_func_name(GDFunctions::Function(i))==p_symbol) {
-			r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-			r_result.class_name="@GDScript";
-			r_result.class_member=p_symbol;
+	for (int i = 0; i < GDFunctions::FUNC_MAX; i++) {
+		if (GDFunctions::get_func_name(GDFunctions::Function(i)) == p_symbol) {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+			r_result.class_name = "@GDScript";
+			r_result.class_member = p_symbol;
 			return OK;
 		}
 	}
 
 	GDParser p;
-	p.parse(p_code,p_base_path,false,"",true);
+	p.parse(p_code, p_base_path, false, "", true);
 
-	if (p.get_completion_type()==GDParser::COMPLETION_NONE)
+	if (p.get_completion_type() == GDParser::COMPLETION_NONE)
 		return ERR_CANT_RESOLVE;
 
 	GDCompletionContext context;
 
-	context._class=p.get_completion_class();
-	context.block=p.get_completion_block();
-	context.function=p.get_completion_function();
-	context.base=p_owner;
-	context.base_path=p_base_path;
-	bool isfunction=false;
+	context._class = p.get_completion_class();
+	context.block = p.get_completion_block();
+	context.function = p.get_completion_function();
+	context.base = p_owner;
+	context.base_path = p_base_path;
+	bool isfunction = false;
 
-	switch(p.get_completion_type()) {
+	switch (p.get_completion_type()) {
 
 		case GDParser::COMPLETION_GET_NODE:
 		case GDParser::COMPLETION_NONE: {
 		} break;
 		case GDParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
 
-			r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
-			r_result.class_name=Variant::get_type_name(p.get_completion_built_in_constant());
-			r_result.class_member=p_symbol;
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+			r_result.class_name = Variant::get_type_name(p.get_completion_built_in_constant());
+			r_result.class_member = p_symbol;
 			return OK;
 
 		} break;
 		case GDParser::COMPLETION_FUNCTION: {
 
-
 			if (context._class && context._class->functions.size()) {
-				for(int i=0;i<context._class->functions.size();i++) {
-					if (context._class->functions[i]->name==p_symbol) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-						r_result.location=context._class->functions[i]->line;
+				for (int i = 0; i < context._class->functions.size(); i++) {
+					if (context._class->functions[i]->name == p_symbol) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.location = context._class->functions[i]->line;
 						return OK;
 					}
 				}
 			}
 
 			Ref<GDScript> parent = _get_parent_class(context);
-			while(parent.is_valid()) {
+			while (parent.is_valid()) {
 				int line = parent->get_member_line(p_symbol);
-				if (line>=0) {
-					r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-					r_result.location=line;
-					r_result.script=parent;
+				if (line >= 0) {
+					r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+					r_result.location = line;
+					r_result.script = parent;
 					return OK;
-
 				}
 
-				parent=parent->get_base();
+				parent = parent->get_base();
 			}
 
 			GDCompletionIdentifier identifier = _get_native_class(context);
-			print_line("identifier: "+String(identifier.obj_type));
+			print_line("identifier: " + String(identifier.obj_type));
 
-			if (ClassDB::has_method(identifier.obj_type,p_symbol)) {
+			if (ClassDB::has_method(identifier.obj_type, p_symbol)) {
 
-				r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-				r_result.class_name=identifier.obj_type;
-				r_result.class_member=p_symbol;
+				r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+				r_result.class_name = identifier.obj_type;
+				r_result.class_member = p_symbol;
 				return OK;
 			}
 
-
 		} break;
 		case GDParser::COMPLETION_IDENTIFIER: {
 
 			//check if a function
 			if (p.get_completion_identifier_is_function()) {
 				if (context._class && context._class->functions.size()) {
-					for(int i=0;i<context._class->functions.size();i++) {
-						if (context._class->functions[i]->name==p_symbol) {
-							r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-							r_result.location=context._class->functions[i]->line;
+					for (int i = 0; i < context._class->functions.size(); i++) {
+						if (context._class->functions[i]->name == p_symbol) {
+							r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+							r_result.location = context._class->functions[i]->line;
 							return OK;
 						}
 					}
 				}
 
 				Ref<GDScript> parent = _get_parent_class(context);
-				while(parent.is_valid()) {
+				while (parent.is_valid()) {
 					int line = parent->get_member_line(p_symbol);
-					if (line>=0) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-						r_result.location=line;
-						r_result.script=parent;
+					if (line >= 0) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.location = line;
+						r_result.script = parent;
 						return OK;
-
 					}
 
-					parent=parent->get_base();
+					parent = parent->get_base();
 				}
 
 				GDCompletionIdentifier identifier = _get_native_class(context);
 
+				if (ClassDB::has_method(identifier.obj_type, p_symbol)) {
 
-				if (ClassDB::has_method(identifier.obj_type,p_symbol)) {
-
-					r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-					r_result.class_name=identifier.obj_type;
-					r_result.class_member=p_symbol;
+					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+					r_result.class_name = identifier.obj_type;
+					r_result.class_member = p_symbol;
 					return OK;
 				}
 			} else {
 
-
 				GDCompletionIdentifier gdi = _get_native_class(context);
-				if (gdi.obj_type!=StringName()) {
+				if (gdi.obj_type != StringName()) {
 					bool valid;
-					Variant::Type t = ClassDB::get_property_type(gdi.obj_type,p_symbol,&valid);
-					if (t!=Variant::NIL && valid) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
-						r_result.class_name=gdi.obj_type;
-						r_result.class_member=p_symbol;
+					Variant::Type t = ClassDB::get_property_type(gdi.obj_type, p_symbol, &valid);
+					if (t != Variant::NIL && valid) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+						r_result.class_name = gdi.obj_type;
+						r_result.class_member = p_symbol;
 						return OK;
-
 					}
 				}
 
-				const GDParser::BlockNode *block=context.block;
+				const GDParser::BlockNode *block = context.block;
 				//search in blocks going up (local var?)
-				while(block) {
-
+				while (block) {
 
+					for (int i = 0; i < block->statements.size(); i++) {
 
-					for (int i=0;i<block->statements.size();i++) {
-
-						if (block->statements[i]->line>p.get_completion_line())
+						if (block->statements[i]->line > p.get_completion_line())
 							continue;
 
+						if (block->statements[i]->type == GDParser::BlockNode::TYPE_LOCAL_VAR) {
 
-						if (block->statements[i]->type==GDParser::BlockNode::TYPE_LOCAL_VAR) {
-
-							const GDParser::LocalVarNode *lv=static_cast<const GDParser::LocalVarNode *>(block->statements[i]);
+							const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(block->statements[i]);
 
-							if (lv->assign && lv->name==p_symbol) {
+							if (lv->assign && lv->name == p_symbol) {
 
-								r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-								r_result.location=block->statements[i]->line;
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = block->statements[i]->line;
 								return OK;
 							}
 						}
 					}
-					block=block->parent_block;
+					block = block->parent_block;
 				}
 
 				//guess from function arguments
-				if (context.function && context.function->name!=StringName()) {
+				if (context.function && context.function->name != StringName()) {
 
-					for(int i=0;i<context.function->arguments.size();i++) {
+					for (int i = 0; i < context.function->arguments.size(); i++) {
 
-						if (context.function->arguments[i]==p_symbol) {
-							r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-							r_result.location=context.function->line;
+						if (context.function->arguments[i] == p_symbol) {
+							r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+							r_result.location = context.function->line;
 							return OK;
 						}
-
 					}
 				}
 
 				//guess in class constants
 
-				for(int i=0;i<context._class->constant_expressions.size();i++) {
+				for (int i = 0; i < context._class->constant_expressions.size(); i++) {
 
-					if (context._class->constant_expressions[i].identifier==p_symbol) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-						r_result.location=context._class->constant_expressions[i].expression->line;
+					if (context._class->constant_expressions[i].identifier == p_symbol) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.location = context._class->constant_expressions[i].expression->line;
 						return OK;
 					}
 				}
@@ -2815,12 +2646,12 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol
 				//guess in class variables
 				if (!(context.function && context.function->_static)) {
 
-					for(int i=0;i<context._class->variables.size();i++) {
+					for (int i = 0; i < context._class->variables.size(); i++) {
 
-						if (context._class->variables[i].identifier==p_symbol) {
+						if (context._class->variables[i].identifier == p_symbol) {
 
-							r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-							r_result.location=context._class->variables[i].line;
+							r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+							r_result.location = context._class->variables[i].line;
 							return OK;
 						}
 					}
@@ -2830,29 +2661,29 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol
 				List<PropertyInfo> props;
 				GlobalConfig::get_singleton()->get_property_list(&props);
 
-				for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+				for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 
 					String s = E->get().name;
 					if (!s.begins_with("autoload/"))
 						continue;
-					String name = s.get_slice("/",1);
-					if (name==String(p_symbol)) {
+					String name = s.get_slice("/", 1);
+					if (name == String(p_symbol)) {
 
 						String path = GlobalConfig::get_singleton()->get(s);
 						if (path.begins_with("*")) {
-							String script =path.substr(1,path.length());
+							String script = path.substr(1, path.length());
 
 							if (!script.ends_with(".gd")) {
 								//not a script, try find the script anyway,
 								//may have some success
-								script=script.get_basename()+".gd";
+								script = script.get_basename() + ".gd";
 							}
 
 							if (FileAccess::exists(script)) {
 
-								r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-								r_result.location=0;
-								r_result.script=ResourceLoader::load(script);
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = 0;
+								r_result.script = ResourceLoader::load(script);
 								return OK;
 							}
 						}
@@ -2860,33 +2691,32 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol
 				}
 
 				//global
-				for(Map<StringName,int>::Element *E=GDScriptLanguage::get_singleton()->get_global_map().front();E;E=E->next()) {
-					if (E->key()==p_symbol) {
+				for (Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) {
+					if (E->key() == p_symbol) {
 
 						Variant value = GDScriptLanguage::get_singleton()->get_global_array()[E->get()];
-						if (value.get_type()==Variant::OBJECT) {
+						if (value.get_type() == Variant::OBJECT) {
 							Object *obj = value;
 							if (obj) {
 
 								if (obj->cast_to<GDNativeClass>()) {
-									r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS;
-									r_result.class_name=obj->cast_to<GDNativeClass>()->get_name();
+									r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+									r_result.class_name = obj->cast_to<GDNativeClass>()->get_name();
 
 								} else {
-									r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS;
-									r_result.class_name=obj->get_class();
+									r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+									r_result.class_name = obj->get_class();
 								}
 								return OK;
 							}
 						} else {
 
-							r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
-							r_result.class_name="@Global Scope";
-							r_result.class_member=p_symbol;
+							r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+							r_result.class_name = "@Global Scope";
+							r_result.class_member = p_symbol;
 							return OK;
 						}
 					}
-
 				}
 #if 0
 				GDCompletionIdentifier identifier;
@@ -2907,122 +2737,109 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol
 
 		} break;
 		case GDParser::COMPLETION_METHOD:
-			isfunction=true;
+			isfunction = true;
 		case GDParser::COMPLETION_INDEX: {
 
 			const GDParser::Node *node = p.get_completion_node();
-			if (node->type!=GDParser::Node::TYPE_OPERATOR)
+			if (node->type != GDParser::Node::TYPE_OPERATOR)
 				break;
 
-
-
-
 			GDCompletionIdentifier t;
-			if (_guess_expression_type(context,static_cast<const GDParser::OperatorNode *>(node)->arguments[0],p.get_completion_line(),t)) {
+			if (_guess_expression_type(context, static_cast<const GDParser::OperatorNode *>(node)->arguments[0], p.get_completion_line(), t)) {
 
-				if (t.type==Variant::OBJECT && t.obj_type=="GDNativeClass") {
+				if (t.type == Variant::OBJECT && t.obj_type == "GDNativeClass") {
 					//native enum
 					Ref<GDNativeClass> gdn = t.value;
 					if (gdn.is_valid()) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
-						r_result.class_name=gdn->get_name();
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+						r_result.class_name = gdn->get_name();
+						r_result.class_member = p_symbol;
 						return OK;
-
 					}
-				} else if (t.type==Variant::OBJECT && t.obj_type!=StringName()) {
+				} else if (t.type == Variant::OBJECT && t.obj_type != StringName()) {
 
 					Ref<GDScript> on_script;
 
 					if (t.value.get_type()) {
-						Object *obj=t.value;
-
+						Object *obj = t.value;
 
 						if (obj) {
 
-
-							on_script=obj->get_script();
+							on_script = obj->get_script();
 
 							if (on_script.is_valid()) {
 								int loc = on_script->get_member_line(p_symbol);
-								if (loc>=0) {
-									r_result.script=on_script;
-									r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
-									r_result.location=loc;
+								if (loc >= 0) {
+									r_result.script = on_script;
+									r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+									r_result.location = loc;
 									return OK;
 								}
 							}
 						}
 					}
 
-					if (ClassDB::has_method(t.obj_type,p_symbol)) {
+					if (ClassDB::has_method(t.obj_type, p_symbol)) {
 
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-						r_result.class_name=t.obj_type;
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+						r_result.class_name = t.obj_type;
+						r_result.class_member = p_symbol;
 						return OK;
-
 					}
 
 					bool success;
-					ClassDB::get_integer_constant(t.obj_type,p_symbol,&success);
+					ClassDB::get_integer_constant(t.obj_type, p_symbol, &success);
 					if (success) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
-						r_result.class_name=t.obj_type;
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+						r_result.class_name = t.obj_type;
+						r_result.class_member = p_symbol;
 						return OK;
 					}
 
-
-					ClassDB::get_property_type(t.obj_type,p_symbol,&success);
+					ClassDB::get_property_type(t.obj_type, p_symbol, &success);
 
 					if (success) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
-						r_result.class_name=t.obj_type;
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+						r_result.class_name = t.obj_type;
+						r_result.class_member = p_symbol;
 						return OK;
 					}
 
-
 				} else {
 
 					Variant::CallError ce;
-					Variant v = Variant::construct(t.type,NULL,0,ce);
+					Variant v = Variant::construct(t.type, NULL, 0, ce);
 
 					bool valid;
-					v.get_numeric_constant_value(t.type,p_symbol,&valid);
+					v.get_numeric_constant_value(t.type, p_symbol, &valid);
 					if (valid) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
-						r_result.class_name=Variant::get_type_name(t.type);
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+						r_result.class_name = Variant::get_type_name(t.type);
+						r_result.class_member = p_symbol;
 						return OK;
 					}
 
 					//todo check all inputevent types for property
 
-					v.get(p_symbol,&valid);
+					v.get(p_symbol, &valid);
 
 					if (valid) {
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
-						r_result.class_name=Variant::get_type_name(t.type);
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+						r_result.class_name = Variant::get_type_name(t.type);
+						r_result.class_member = p_symbol;
 						return OK;
 					}
 
 					if (v.has_method(p_symbol)) {
 
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-						r_result.class_name=Variant::get_type_name(t.type);
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+						r_result.class_name = Variant::get_type_name(t.type);
+						r_result.class_member = p_symbol;
 						return OK;
-
 					}
-
-
 				}
 			}
 
-
 		} break;
 		case GDParser::COMPLETION_CALL_ARGUMENTS: {
 
@@ -3032,18 +2849,17 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol
 
 			GDCompletionIdentifier cid = _get_native_class(context);
 
-			if (cid.obj_type!=StringName()) {
+			if (cid.obj_type != StringName()) {
 				List<MethodInfo> vm;
-				ClassDB::get_virtual_methods(cid.obj_type,&vm);
-				for(List<MethodInfo>::Element *E=vm.front();E;E=E->next()) {
+				ClassDB::get_virtual_methods(cid.obj_type, &vm);
+				for (List<MethodInfo>::Element *E = vm.front(); E; E = E->next()) {
 
-					if (p_symbol==E->get().name) {
+					if (p_symbol == E->get().name) {
 
-						r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-						r_result.class_name=cid.obj_type;
-						r_result.class_member=p_symbol;
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+						r_result.class_name = cid.obj_type;
+						r_result.class_member = p_symbol;
 						return OK;
-
 					}
 				}
 			}
@@ -3053,10 +2869,8 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol
 			return ERR_CANT_RESOLVE;
 
 		} break;
-
 	}
 
-
 	return ERR_CANT_RESOLVE;
 }
 
-- 
cgit v1.2.3-70-g09d2