更为细致的命名风格检测，施工中...

CppCXY · CppCXY · commit 5559b0a7e6a1 · 2021-12-07T00:23:27.000+08:00
diff --git a/CodeFormatServer/src/LanguageClient.cpp b/CodeFormatServer/src/LanguageClient.cpp
@@ -45,6 +45,8 @@ void LanguageClient::SendNotification(std::string_view method, std::shared_ptr<v
 
 void LanguageClient::CacheFile(std::string_view uri, std::shared_ptr<LuaParser> parser)
 {
+	std::filesystem::path path(uri);
+	parser->SetFilename(path.filename().string());
 	_fileMap[std::string(uri)] = parser;
 }
 
diff --git a/CodeService/src/NameStyle/NameStyleChecker.cpp b/CodeService/src/NameStyle/NameStyleChecker.cpp
@@ -1,5 +1,7 @@
 ﻿#include "CodeService/NameStyle/NameStyleChecker.h"
 #include <algorithm>
+#include "Util/format.h"
+#include "CodeService/LanguageTranslator.h"
 
 NameStyleChecker::NameStyleChecker(DiagnosisContext& ctx)
 	: _ctx(ctx)
@@ -8,6 +10,21 @@ NameStyleChecker::NameStyleChecker(DiagnosisContext& ctx)
 
 std::vector<LuaDiagnosisInfo> NameStyleChecker::Analysis()
 {
+	for (auto checkElement : _nameStyleCheckVector)
+	{
+		if (checkElement->Type == NameDefineType::ModuleDefineName)
+		{
+			auto parser = _ctx.GetParser();
+
+			auto filename = parser->GetFilename();
+
+			if (checkElement->Node->GetText() != filename)
+			{
+				_ctx.PushDiagnosis(format(LText("module name must be {}"), filename),
+				                   checkElement->Node->GetTextRange());
+			}
+		}
+	}
 	// if (ctx.GetOptions().enable_name_style_check)
 	// {
 	// 	switch (_textDefineType)
@@ -95,7 +112,9 @@ void NameStyleChecker::VisitLocalStatement(const std::shared_ptr<LuaAstNode>& lo
 			auto nameIdentify = nameVector[index];
 			if (index >= expressionVector.size())
 			{
-				_nameStyleCheckVector.push_back({NameDefineType::LocalVariableName, nameIdentify});
+				auto checkElement = std::make_shared<CheckElement>(NameDefineType::LocalVariableName, nameIdentify);
+				_nameStyleCheckVector.push_back(checkElement);
+				RecordLocalVariable(checkElement);
 				continue;
 			}
 			auto expression = expressionVector[index];
@@ -110,20 +129,27 @@ void NameStyleChecker::VisitLocalStatement(const std::shared_ptr<LuaAstNode>& lo
 					if (methodNameNode->GetText() == "require" || methodNameNode->GetText() == "import")
 					{
 						auto callArgsList = callExpression->FindFirstOf(LuaAstNodeType::CallArgList);
-						_nameStyleCheckVector.push_back({NameDefineType::ImportModuleName, nameIdentify, callArgsList});
+
+						auto checkElement = std::make_shared<CheckElement>(
+							NameDefineType::ImportModuleName, nameIdentify, callArgsList);
+						_nameStyleCheckVector.push_back(checkElement);
+						RecordLocalVariable(checkElement);
 						continue;
 					}
 					else if (methodNameNode->GetText() == "Class" || methodNameNode->GetText() == "class")
 					{
 						auto callArgsList = callExpression->FindFirstOf(LuaAstNodeType::CallArgList);
-						_nameStyleCheckVector.push_back({
-							NameDefineType::ClassVariableName, nameIdentify, callArgsList
-						});
+						auto checkElement = std::make_shared<CheckElement>(
+							NameDefineType::ClassVariableName, nameIdentify, callArgsList);
+						_nameStyleCheckVector.push_back(checkElement);
+						RecordLocalVariable(checkElement);
 						continue;
 					}
 				}
 			}
-			_nameStyleCheckVector.push_back({NameDefineType::LocalVariableName, nameIdentify});
+			auto checkElement = std::make_shared<CheckElement>(NameDefineType::LocalVariableName, nameIdentify);
+			_nameStyleCheckVector.push_back(checkElement);
+			RecordLocalVariable(checkElement);
 		}
 	}
 	else if (nameDefineList)
@@ -132,7 +158,9 @@ void NameStyleChecker::VisitLocalStatement(const std::shared_ptr<LuaAstNode>& lo
 		{
 			if (nameIdentify->GetType() == LuaAstNodeType::Identify)
 			{
-				_nameStyleCheckVector.push_back({NameDefineType::LocalVariableName, nameIdentify});
+				auto checkElement = std::make_shared<CheckElement>(NameDefineType::LocalVariableName, nameIdentify);
+				_nameStyleCheckVector.push_back(checkElement);
+				RecordLocalVariable(checkElement);
 			}
 		}
 	}
@@ -144,7 +172,7 @@ void NameStyleChecker::VisitParamList(const std::shared_ptr<LuaAstNode>& paramLi
 	{
 		if (param->GetType() == LuaAstNodeType::Identify)
 		{
-			_nameStyleCheckVector.push_back({NameDefineType::ParamName, param});
+			_nameStyleCheckVector.push_back(std::make_shared<CheckElement>(NameDefineType::ParamName, param));
 		}
 	}
 }
@@ -155,7 +183,7 @@ void NameStyleChecker::VisitLocalFunctionStatement(const std::shared_ptr<LuaAstN
 	{
 		if (child->GetType() == LuaAstNodeType::Identify)
 		{
-			_nameStyleCheckVector.push_back({NameDefineType::LocalFunctionName, child});
+			_nameStyleCheckVector.push_back(std::make_shared<CheckElement>(NameDefineType::LocalFunctionName, child));
 			break;
 		}
 	}
@@ -184,7 +212,8 @@ void NameStyleChecker::VisitFunctionStatement(const std::shared_ptr<LuaAstNode>&
 			if (lastElement && lastElement->GetType() == LuaAstNodeType::Identify
 				|| lastElement->GetType() == LuaAstNodeType::PrimaryExpression)
 			{
-				_nameStyleCheckVector.push_back({NameDefineType::FunctionDefineName, lastElement});
+				_nameStyleCheckVector.push_back(
+					std::make_shared<CheckElement>(NameDefineType::FunctionDefineName, lastElement));
 			}
 		}
 	}
@@ -203,7 +232,8 @@ void NameStyleChecker::VisitAssignment(const std::shared_ptr<LuaAstNode>& assign
 			{
 				if (IsGlobal(expressionFirstChild))
 				{
-					_nameStyleCheckVector.push_back({NameDefineType::GlobalVariableDefineName, expressionFirstChild});
+					_nameStyleCheckVector.push_back(
+						std::make_shared<CheckElement>(NameDefineType::GlobalVariableDefineName, expressionFirstChild));
 				}
 			}
 			else if (expressionFirstChild->GetType() == LuaAstNodeType::IndexExpression)
@@ -224,7 +254,8 @@ void NameStyleChecker::VisitAssignment(const std::shared_ptr<LuaAstNode>& assign
 
 				if (lastElement && lastElement->GetType() == LuaAstNodeType::Identify)
 				{
-					_nameStyleCheckVector.push_back({NameDefineType::FunctionDefineName, lastElement});
+					_nameStyleCheckVector.push_back(
+						std::make_shared<CheckElement>(NameDefineType::FunctionDefineName, lastElement));
 				}
 			}
 		}
@@ -237,7 +268,7 @@ void NameStyleChecker::VisitTableField(const std::shared_ptr<LuaAstNode>& tableF
 
 	if (identify)
 	{
-		_nameStyleCheckVector.push_back({NameDefineType::TableFieldDefineName, identify});
+		_nameStyleCheckVector.push_back(std::make_shared<CheckElement>(NameDefineType::TableFieldDefineName, identify));
 	}
 }
 
@@ -249,9 +280,23 @@ void NameStyleChecker::VisitReturnStatement(const std::shared_ptr<LuaAstNode>& r
 		if (expressionList && !expressionList->GetChildren().empty())
 		{
 			auto firstReturnExpression = expressionList->GetChildren().front();
-			if (firstReturnExpression->GetType() == LuaAstNodeType::PrimaryExpression)
+			if (firstReturnExpression->GetType() == LuaAstNodeType::Expression)
 			{
-				auto block = returnStatement->GetParent();
+				auto primaryReturnIdentify = firstReturnExpression->FindFirstOf(LuaAstNodeType::PrimaryExpression);
+				if (primaryReturnIdentify)
+				{
+					auto block = returnStatement->GetParent();
+
+					if (_scopeMap.count(block))
+					{
+						auto& scope = _scopeMap[block];
+						auto it = scope.LocalVariableMap.find(primaryReturnIdentify->GetText());
+						if (it != scope.LocalVariableMap.end())
+						{
+							it->second->Type = NameDefineType::ModuleDefineName;
+						}
+					}
+				}
 			}
 		}
 	}
@@ -262,8 +307,23 @@ void NameStyleChecker::VisitBlock(const std::shared_ptr<LuaAstNode>& block)
 	_scopeMap.insert({block, Scope()});
 }
 
-void NameStyleChecker::RecordLocalVariable(std::shared_ptr<LuaAstNode> identify)
+void NameStyleChecker::RecordLocalVariable(std::shared_ptr<CheckElement> checkElement)
 {
+	auto node = checkElement->Node;
+	auto parent = node->GetParent();
+	while (parent)
+	{
+		if (parent->GetType() == LuaAstNodeType::Block)
+		{
+			if (_scopeMap.count(parent))
+			{
+				auto& scope = _scopeMap[parent];
+				scope.LocalVariableMap.insert({std::string(node->GetText()), checkElement});
+			}
+			break;
+		}
+		parent = parent->GetParent();
+	}
 }
 
 bool NameStyleChecker::InTopBlock(std::shared_ptr<LuaAstNode> chunkBlockStatement)
@@ -279,6 +339,26 @@ bool NameStyleChecker::InTopBlock(std::shared_ptr<LuaAstNode> chunkBlockStatemen
 
 bool NameStyleChecker::IsGlobal(std::shared_ptr<LuaAstNode> node)
 {
+	auto identifyText = node->GetText();
+
+	auto parent = node->GetParent();
+	while (parent)
+	{
+		if (parent->GetType() == LuaAstNodeType::Block)
+		{
+			if (_scopeMap.count(parent))
+			{
+				auto& scope = _scopeMap[parent];
+				auto it = scope.LocalVariableMap.find(identifyText);
+				if (it != scope.LocalVariableMap.end())
+				{
+					return false;
+				}
+			}
+		}
+		parent = parent->GetParent();
+	}
+
 	return true;
 }
 
diff --git a/LuaParser/src/LuaAstNode.cpp b/LuaParser/src/LuaAstNode.cpp
@@ -5,8 +5,7 @@
 #include "LuaParser/LuaAstVisitor.h"
 
 LuaAstNode::LuaAstNode(LuaAstNodeType type, const char* source)
-	: _parent(),
-	  _type(type),
+	: _type(type),
 	  _text(source, 0),
 	  _source(source),
 	  _textRange(0, 0)
@@ -170,7 +169,7 @@ void LuaAstNode::AddLeafChild(std::shared_ptr<LuaAstNode> child)
 
 std::shared_ptr<LuaAstNode> LuaAstNode::GetParent()
 {
-	if(!_parent.expired())
+	if (!_parent.expired())
 	{
 		return _parent.lock();
 	}
diff --git a/LuaParser/src/LuaParser.cpp b/LuaParser/src/LuaParser.cpp
@@ -20,7 +20,9 @@ std::shared_ptr<LuaParser> LuaParser::LoadFromFile(std::string_view filename)
 	{
 		std::stringstream s;
 		s << fin.rdbuf();
-		return LoadFromBuffer(s.str());
+		auto parser = LoadFromBuffer(s.str());
+		parser->SetFilename(filePath.filename().string());
+		return parser;
 	}
 
 	return nullptr;
@@ -94,6 +96,18 @@ bool LuaParser::IsEmptyLine(int line)
 	return _tokenParser->IsEmptyLine(line);
 }
 
+void LuaParser::SetFilename(std::string_view filename)
+{
+	std::filesystem::path path(filename);
+	
+	_filename = path.replace_extension().string();
+}
+
+std::string_view LuaParser::GetFilename()
+{
+	return _filename;
+}
+
 void LuaParser::BuildAstWithComment()
 {
 	BuildAst();
diff --git a/include/CodeService/NameStyle/NameStyleChecker.h b/include/CodeService/NameStyle/NameStyleChecker.h
@@ -19,7 +19,7 @@ class NameStyleChecker : public LuaAstVisitor
 	class Scope
 	{
 	public:
-
+		std::map<std::string, std::shared_ptr<CheckElement>, std::less<>> LocalVariableMap;
 	};
 
 	NameStyleChecker(DiagnosisContext& ctx);
@@ -36,7 +36,7 @@ class NameStyleChecker : public LuaAstVisitor
 	void VisitReturnStatement(const std::shared_ptr<LuaAstNode>& node) override;
 	void VisitBlock(const std::shared_ptr<LuaAstNode>& node) override;
 private:
-	void RecordLocalVariable(std::shared_ptr<LuaAstNode> identify);
+	void RecordLocalVariable(std::shared_ptr<CheckElement> checkElement);
 	bool InTopBlock(std::shared_ptr<LuaAstNode> chunkBlockStatement);
 	bool IsGlobal(std::shared_ptr<LuaAstNode> node);
 	bool SnakeCase(std::string_view source);
@@ -47,7 +47,7 @@ class NameStyleChecker : public LuaAstVisitor
 
 	// block到作用域的映射
 	std::map<std::shared_ptr<LuaAstNode>, Scope> _scopeMap;
-	std::vector<CheckElement> _nameStyleCheckVector;
+	std::vector<std::shared_ptr<CheckElement>> _nameStyleCheckVector;
 	std::string_view _moduleName;
 
 };
diff --git a/include/LuaParser/LuaAstNode.h b/include/LuaParser/LuaAstNode.h
@@ -46,12 +46,12 @@ class LuaAstNode: public std::enable_shared_from_this<LuaAstNode>
 	void addChildAfter(int index, std::shared_ptr<LuaAstNode> child);
 	void addChildBefore(int index, std::shared_ptr<LuaAstNode> child);
 
-	std::weak_ptr<LuaAstNode> _parent;
 	LuaAstNodeType _type;
 	std::string_view _text;
 
 	const char* _source;
 	TextRange _textRange;
 	std::vector<std::shared_ptr<LuaAstNode>> _children;
 	std::string _error;
+	std::weak_ptr<LuaAstNode> _parent;
 };
diff --git a/include/LuaParser/LuaParser.h b/include/LuaParser/LuaParser.h
@@ -37,6 +37,9 @@ class LuaParser
 
 	bool IsEmptyLine(int line);
 
+	void SetFilename(std::string_view filename);
+
+	std::string_view GetFilename();
 private:
 	bool BlockFollow(bool withUntil = false);
 
@@ -162,4 +165,6 @@ class LuaParser
 	std::shared_ptr<LuaAstNode> _chunkAstNode;
 
 	std::vector<LuaError> _errors;
+
+	std::string _filename;
 };
diff --git a/include/LuaParser/LuaTokenParser.h b/include/LuaParser/LuaTokenParser.h
@@ -42,6 +42,7 @@ class LuaTokenParser
 	std::vector<LuaError>& GetErrors();
 
 	bool HasError() const;
+
 private:
 	static std::map<std::string, LuaTokenType, std::less<>> LuaReserved;
 
diff --git a/lua.template.editorconfig b/lua.template.editorconfig
@@ -40,8 +40,16 @@ insert_final_newline = true
 
 
 # the following is name style check rule 
-# optional off/camel_case/snake_case/pascal_case
+# base option off/camel_case/snake_case/pascal_case
 enable_name_style_check = false
 local_name_define_style = snake_case
-function_name_define_style = off
-table_field_name_define_style = off
+function_name_define_style = snake_case
+table_field_name_define_style = snake_case
+global_variable_name_define_style = snake_case
+# the following has extra option: same:filename/first_param/'<const string>', snake_case/pascal_case/camel_case
+# for example:
+# same:first_param, snake_case
+# same:'m'
+module_name_define_style = same:filename, snake_case
+require_module_name_sytle = same:first_param, snake_case
+class_name_define_style = same:first_param

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,8 @@ void LanguageClient::SendNotification(std::string_view method, std::shared_ptr<v`
`45`	`45`
`46`	`46`	`void LanguageClient::CacheFile(std::string_view uri, std::shared_ptr<LuaParser> parser)`
`47`	`47`	`{`
	`48`	`+ std::filesystem::path path(uri);`
	`49`	`+ parser->SetFilename(path.filename().string());`
`48`	`50`	`_fileMap[std::string(uri)] = parser;`
`49`	`51`	`}`
`50`	`52`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`#include "CodeService/NameStyle/NameStyleChecker.h"`
`2`	`2`	`#include <algorithm>`
	`3`	`+#include "Util/format.h"`
	`4`	`+#include "CodeService/LanguageTranslator.h"`
`3`	`5`
`4`	`6`	`NameStyleChecker::NameStyleChecker(DiagnosisContext& ctx)`
`5`	`7`	`: _ctx(ctx)`
`@@ -8,6 +10,21 @@ NameStyleChecker::NameStyleChecker(DiagnosisContext& ctx)`
`8`	`10`
`9`	`11`	`std::vector<LuaDiagnosisInfo> NameStyleChecker::Analysis()`
`10`	`12`	`{`
	`13`	`+ for (auto checkElement : _nameStyleCheckVector)`
	`14`	`+ {`
	`15`	`+ if (checkElement->Type == NameDefineType::ModuleDefineName)`
	`16`	`+ {`
	`17`	`+ auto parser = _ctx.GetParser();`
	`18`	`+`
	`19`	`+ auto filename = parser->GetFilename();`
	`20`	`+`
	`21`	`+ if (checkElement->Node->GetText() != filename)`
	`22`	`+ {`
	`23`	`+ _ctx.PushDiagnosis(format(LText("module name must be {}"), filename),`
	`24`	`+ checkElement->Node->GetTextRange());`
	`25`	`+ }`
	`26`	`+ }`
	`27`	`+ }`
`11`	`28`	`// if (ctx.GetOptions().enable_name_style_check)`
`12`	`29`	`// {`
`13`	`30`	`// switch (_textDefineType)`
`@@ -95,7 +112,9 @@ void NameStyleChecker::VisitLocalStatement(const std::shared_ptr<LuaAstNode>& lo`
`95`	`112`	`auto nameIdentify = nameVector[index];`
`96`	`113`	`if (index >= expressionVector.size())`
`97`	`114`	`{`
`98`		`- _nameStyleCheckVector.push_back({NameDefineType::LocalVariableName, nameIdentify});`
	`115`	`+ auto checkElement = std::make_shared<CheckElement>(NameDefineType::LocalVariableName, nameIdentify);`
	`116`	`+ _nameStyleCheckVector.push_back(checkElement);`
	`117`	`+ RecordLocalVariable(checkElement);`
`99`	`118`	`continue;`
`100`	`119`	`}`
`101`	`120`	`auto expression = expressionVector[index];`
`@@ -110,20 +129,27 @@ void NameStyleChecker::VisitLocalStatement(const std::shared_ptr<LuaAstNode>& lo`
`110`	`129`	`if (methodNameNode->GetText() == "require" \|\| methodNameNode->GetText() == "import")`
`111`	`130`	`{`
`112`	`131`	`auto callArgsList = callExpression->FindFirstOf(LuaAstNodeType::CallArgList);`
`113`		`- _nameStyleCheckVector.push_back({NameDefineType::ImportModuleName, nameIdentify, callArgsList});`
	`132`	`+`
	`133`	`+ auto checkElement = std::make_shared<CheckElement>(`
	`134`	`+ NameDefineType::ImportModuleName, nameIdentify, callArgsList);`
	`135`	`+ _nameStyleCheckVector.push_back(checkElement);`
	`136`	`+ RecordLocalVariable(checkElement);`
`114`	`137`	`continue;`
`115`	`138`	`}`
`116`	`139`	`else if (methodNameNode->GetText() == "Class" \|\| methodNameNode->GetText() == "class")`
`117`	`140`	`{`
`118`	`141`	`auto callArgsList = callExpression->FindFirstOf(LuaAstNodeType::CallArgList);`
`119`		`- _nameStyleCheckVector.push_back({`
`120`		`- NameDefineType::ClassVariableName, nameIdentify, callArgsList`
`121`		`- });`
	`142`	`+ auto checkElement = std::make_shared<CheckElement>(`
	`143`	`+ NameDefineType::ClassVariableName, nameIdentify, callArgsList);`
	`144`	`+ _nameStyleCheckVector.push_back(checkElement);`
	`145`	`+ RecordLocalVariable(checkElement);`
`122`	`146`	`continue;`
`123`	`147`	`}`
`124`	`148`	`}`
`125`	`149`	`}`
`126`		`- _nameStyleCheckVector.push_back({NameDefineType::LocalVariableName, nameIdentify});`
	`150`	`+ auto checkElement = std::make_shared<CheckElement>(NameDefineType::LocalVariableName, nameIdentify);`
	`151`	`+ _nameStyleCheckVector.push_back(checkElement);`
	`152`	`+ RecordLocalVariable(checkElement);`
`127`	`153`	`}`
`128`	`154`	`}`
`129`	`155`	`else if (nameDefineList)`
`@@ -132,7 +158,9 @@ void NameStyleChecker::VisitLocalStatement(const std::shared_ptr<LuaAstNode>& lo`
`132`	`158`	`{`
`133`	`159`	`if (nameIdentify->GetType() == LuaAstNodeType::Identify)`
`134`	`160`	`{`
`135`		`- _nameStyleCheckVector.push_back({NameDefineType::LocalVariableName, nameIdentify});`
	`161`	`+ auto checkElement = std::make_shared<CheckElement>(NameDefineType::LocalVariableName, nameIdentify);`
	`162`	`+ _nameStyleCheckVector.push_back(checkElement);`
	`163`	`+ RecordLocalVariable(checkElement);`
`136`	`164`	`}`
`137`	`165`	`}`
`138`	`166`	`}`
`@@ -144,7 +172,7 @@ void NameStyleChecker::VisitParamList(const std::shared_ptr<LuaAstNode>& paramLi`
`144`	`172`	`{`
`145`	`173`	`if (param->GetType() == LuaAstNodeType::Identify)`
`146`	`174`	`{`
`147`		`- _nameStyleCheckVector.push_back({NameDefineType::ParamName, param});`
	`175`	`+ _nameStyleCheckVector.push_back(std::make_shared<CheckElement>(NameDefineType::ParamName, param));`
`148`	`176`	`}`
`149`	`177`	`}`
`150`	`178`	`}`
`@@ -155,7 +183,7 @@ void NameStyleChecker::VisitLocalFunctionStatement(const std::shared_ptr<LuaAstN`
`155`	`183`	`{`
`156`	`184`	`if (child->GetType() == LuaAstNodeType::Identify)`
`157`	`185`	`{`
`158`		`- _nameStyleCheckVector.push_back({NameDefineType::LocalFunctionName, child});`
	`186`	`+ _nameStyleCheckVector.push_back(std::make_shared<CheckElement>(NameDefineType::LocalFunctionName, child));`
`159`	`187`	`break;`
`160`	`188`	`}`
`161`	`189`	`}`
`@@ -184,7 +212,8 @@ void NameStyleChecker::VisitFunctionStatement(const std::shared_ptr<LuaAstNode>&`
`184`	`212`	`if (lastElement && lastElement->GetType() == LuaAstNodeType::Identify`
`185`	`213`	`\|\| lastElement->GetType() == LuaAstNodeType::PrimaryExpression)`
`186`	`214`	`{`
`187`		`- _nameStyleCheckVector.push_back({NameDefineType::FunctionDefineName, lastElement});`
	`215`	`+ _nameStyleCheckVector.push_back(`
	`216`	`+ std::make_shared<CheckElement>(NameDefineType::FunctionDefineName, lastElement));`
`188`	`217`	`}`
`189`	`218`	`}`
`190`	`219`	`}`
`@@ -203,7 +232,8 @@ void NameStyleChecker::VisitAssignment(const std::shared_ptr<LuaAstNode>& assign`
`203`	`232`	`{`
`204`	`233`	`if (IsGlobal(expressionFirstChild))`
`205`	`234`	`{`
`206`		`- _nameStyleCheckVector.push_back({NameDefineType::GlobalVariableDefineName, expressionFirstChild});`
	`235`	`+ _nameStyleCheckVector.push_back(`
	`236`	`+ std::make_shared<CheckElement>(NameDefineType::GlobalVariableDefineName, expressionFirstChild));`
`207`	`237`	`}`
`208`	`238`	`}`
`209`	`239`	`else if (expressionFirstChild->GetType() == LuaAstNodeType::IndexExpression)`
`@@ -224,7 +254,8 @@ void NameStyleChecker::VisitAssignment(const std::shared_ptr<LuaAstNode>& assign`
`224`	`254`
`225`	`255`	`if (lastElement && lastElement->GetType() == LuaAstNodeType::Identify)`
`226`	`256`	`{`
`227`		`- _nameStyleCheckVector.push_back({NameDefineType::FunctionDefineName, lastElement});`
	`257`	`+ _nameStyleCheckVector.push_back(`
	`258`	`+ std::make_shared<CheckElement>(NameDefineType::FunctionDefineName, lastElement));`
`228`	`259`	`}`
`229`	`260`	`}`
`230`	`261`	`}`
`@@ -237,7 +268,7 @@ void NameStyleChecker::VisitTableField(const std::shared_ptr<LuaAstNode>& tableF`
`237`	`268`
`238`	`269`	`if (identify)`
`239`	`270`	`{`
`240`		`- _nameStyleCheckVector.push_back({NameDefineType::TableFieldDefineName, identify});`
	`271`	`+ _nameStyleCheckVector.push_back(std::make_shared<CheckElement>(NameDefineType::TableFieldDefineName, identify));`
`241`	`272`	`}`
`242`	`273`	`}`
`243`	`274`
`@@ -249,9 +280,23 @@ void NameStyleChecker::VisitReturnStatement(const std::shared_ptr<LuaAstNode>& r`
`249`	`280`	`if (expressionList && !expressionList->GetChildren().empty())`
`250`	`281`	`{`
`251`	`282`	`auto firstReturnExpression = expressionList->GetChildren().front();`
`252`		`- if (firstReturnExpression->GetType() == LuaAstNodeType::PrimaryExpression)`
	`283`	`+ if (firstReturnExpression->GetType() == LuaAstNodeType::Expression)`
`253`	`284`	`{`
`254`		`- auto block = returnStatement->GetParent();`
	`285`	`+ auto primaryReturnIdentify = firstReturnExpression->FindFirstOf(LuaAstNodeType::PrimaryExpression);`
	`286`	`+ if (primaryReturnIdentify)`
	`287`	`+ {`
	`288`	`+ auto block = returnStatement->GetParent();`
	`289`	`+`
	`290`	`+ if (_scopeMap.count(block))`
	`291`	`+ {`
	`292`	`+ auto& scope = _scopeMap[block];`
	`293`	`+ auto it = scope.LocalVariableMap.find(primaryReturnIdentify->GetText());`
	`294`	`+ if (it != scope.LocalVariableMap.end())`
	`295`	`+ {`
	`296`	`+ it->second->Type = NameDefineType::ModuleDefineName;`
	`297`	`+ }`
	`298`	`+ }`
	`299`	`+ }`
`255`	`300`	`}`
`256`	`301`	`}`
`257`	`302`	`}`
`@@ -262,8 +307,23 @@ void NameStyleChecker::VisitBlock(const std::shared_ptr<LuaAstNode>& block)`
`262`	`307`	`_scopeMap.insert({block, Scope()});`
`263`	`308`	`}`
`264`	`309`
`265`		`-void NameStyleChecker::RecordLocalVariable(std::shared_ptr<LuaAstNode> identify)`
	`310`	`+void NameStyleChecker::RecordLocalVariable(std::shared_ptr<CheckElement> checkElement)`
`266`	`311`	`{`
	`312`	`+ auto node = checkElement->Node;`
	`313`	`+ auto parent = node->GetParent();`
	`314`	`+ while (parent)`
	`315`	`+ {`
	`316`	`+ if (parent->GetType() == LuaAstNodeType::Block)`
	`317`	`+ {`
	`318`	`+ if (_scopeMap.count(parent))`
	`319`	`+ {`
	`320`	`+ auto& scope = _scopeMap[parent];`
	`321`	`+ scope.LocalVariableMap.insert({std::string(node->GetText()), checkElement});`
	`322`	`+ }`
	`323`	`+ break;`
	`324`	`+ }`
	`325`	`+ parent = parent->GetParent();`
	`326`	`+ }`
`267`	`327`	`}`
`268`	`328`
`269`	`329`	`bool NameStyleChecker::InTopBlock(std::shared_ptr<LuaAstNode> chunkBlockStatement)`
`@@ -279,6 +339,26 @@ bool NameStyleChecker::InTopBlock(std::shared_ptr<LuaAstNode> chunkBlockStatemen`
`279`	`339`
`280`	`340`	`bool NameStyleChecker::IsGlobal(std::shared_ptr<LuaAstNode> node)`
`281`	`341`	`{`
	`342`	`+ auto identifyText = node->GetText();`
	`343`	`+`
	`344`	`+ auto parent = node->GetParent();`
	`345`	`+ while (parent)`
	`346`	`+ {`
	`347`	`+ if (parent->GetType() == LuaAstNodeType::Block)`
	`348`	`+ {`
	`349`	`+ if (_scopeMap.count(parent))`
	`350`	`+ {`
	`351`	`+ auto& scope = _scopeMap[parent];`
	`352`	`+ auto it = scope.LocalVariableMap.find(identifyText);`
	`353`	`+ if (it != scope.LocalVariableMap.end())`
	`354`	`+ {`
	`355`	`+ return false;`
	`356`	`+ }`
	`357`	`+ }`
	`358`	`+ }`
	`359`	`+ parent = parent->GetParent();`
	`360`	`+ }`
	`361`	`+`
`282`	`362`	`return true;`
`283`	`363`	`}`
`284`	`364`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,7 @@`
`5`	`5`	`#include "LuaParser/LuaAstVisitor.h"`
`6`	`6`
`7`	`7`	`LuaAstNode::LuaAstNode(LuaAstNodeType type, const char* source)`
`8`		`- : _parent(),`
`9`		`- _type(type),`
	`8`	`+ : _type(type),`
`10`	`9`	`_text(source, 0),`
`11`	`10`	`_source(source),`
`12`	`11`	`_textRange(0, 0)`
`@@ -170,7 +169,7 @@ void LuaAstNode::AddLeafChild(std::shared_ptr<LuaAstNode> child)`
`170`	`169`
`171`	`170`	`std::shared_ptr<LuaAstNode> LuaAstNode::GetParent()`
`172`	`171`	`{`
`173`		`- if(!_parent.expired())`
	`172`	`+ if (!_parent.expired())`
`174`	`173`	`{`
`175`	`174`	`return _parent.lock();`
`176`	`175`	`}`