Merge pull request #12 from AlexHaxe/suppresswarnings

AlexHaxe · AlexHaxe · commit 6bf026df7366 · 2015-05-25T11:13:55.000+02:00
added @SuppressWarnings support to disable warnings for one or multiple tests on a Field usage: @SuppressWarnings("checkstyle:CyclomaticComplexity") or @SuppressWarnings(["checkstyle:CyclomaticComplexity", "checkstyle:MethodLength"])
diff --git a/checkstyle/checks/AnonymousCheck.hx b/checkstyle/checks/AnonymousCheck.hx
@@ -19,7 +19,10 @@ class AnonymousCheck extends Check {
 		for (td in _checker.ast.decls) {
 			switch (td.decl){
 				case EClass(d):
-					for (field in d.data) if (field.name != "new") checkField(field);
+					for (field in d.data) {
+						if (isCheckSuppressed (field)) continue;
+						if (field.name != "new") checkField(field);
+					}
 				default:
 			}
 		}
@@ -42,4 +45,4 @@ class AnonymousCheck extends Check {
 	function _error(name:String, pos:Position) {
 		logPos('Anonymous structure found, it is advised to use a typedef instead \"${name}\"', pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/checkstyle/checks/Check.hx b/checkstyle/checks/Check.hx
@@ -1,6 +1,7 @@
 package checkstyle.checks;
 
 import haxe.macro.Expr.Position;
+import haxe.macro.Expr;
 import checkstyle.LintMessage.SeverityLevel;
 
 class Check {
@@ -29,17 +30,48 @@ class Check {
 
 	public function log(msg:String, l:Int, c:Int, sev:SeverityLevel) {
 		_messages.push({
-					  fileName:_checker.file.name,
-					  message:msg,
-					  line:l,
-					  column:c,
-					  severity:sev,
-					  moduleName:getModuleName()
-					  });
+			fileName:_checker.file.name,
+			message:msg,
+			line:l,
+			column:c,
+			severity:sev,
+			moduleName:getModuleName()
+		});
 	}
 
 	public function getModuleName():String {
 		if (_moduleName == null) _moduleName = ChecksInfo.getCheckName(this);
 		return _moduleName;
 	}
-}
+
+	function isCheckSuppressed(f:Field):Bool {
+		if (f == null || f.meta == null) return false;
+
+		var search = 'checkstyle:${getModuleName ()}';
+		for (meta in f.meta) {
+			if (meta.name != "SuppressWarnings") continue;
+			if (meta.params == null) continue;
+			for (param in meta.params) {
+				if (checkSuppressionConst (param, search)) return true;
+			}
+		}
+		return false;
+	}
+
+	function checkSuppressionConst (e:Expr, search:String):Bool {
+		switch (e.expr) {
+			case EArrayDecl (a):
+				for (e1 in a) {
+					if (checkSuppressionConst (e1, search)) return true;
+				}
+			case EConst (c):
+				switch (c) {
+					case CString (s):
+						if (s == search) return true;
+					default:
+				}
+			default:
+		}
+		return false;
+	}
+}
diff --git a/checkstyle/checks/ConstantNameCheck.hx b/checkstyle/checks/ConstantNameCheck.hx
@@ -32,6 +32,7 @@ class ConstantNameCheck extends NameCheckBase {
 
 	function checkFields(d:Array<Field>) {
 		for (field in d) {
+			if (isCheckSuppressed (field)) continue;
 			switch (field.kind) {
 				case FVar (t, e):
 					checkField(field, t, e);
diff --git a/checkstyle/checks/CyclomaticComplexityCheck.hx b/checkstyle/checks/CyclomaticComplexityCheck.hx
@@ -32,7 +32,11 @@ class CyclomaticComplexityCheck extends Check {
 	function checkFields(definition:Definition<ClassFlag, Array<Field>>) {
 		definition.data.map(function(field:Field):Null<Target> {
 			return switch (field.kind) {
-				case FieldType.FFun(f): {name:field.name, expr:f.expr, pos:field.pos};
+				case FieldType.FFun(f): 
+					if (isCheckSuppressed (field))
+						null;
+					else
+						{name:field.name, expr:f.expr, pos:field.pos};
 				default: null;
 			}
 		}).filter(function(f:Null<Target>):Bool {
@@ -53,6 +57,7 @@ class CyclomaticComplexityCheck extends Check {
 	}
 
 	// This would not pass the cyclomatic complexity test.
+	@SuppressWarnings('checkstyle:CyclomaticComplexity')
 	function evaluateExpr(e:Expr):Int {
 		if (e == null || e.expr == null) {
 			return 0;
@@ -119,4 +124,4 @@ typedef Target = {
 typedef Threshold = {
 	var severity:String;
 	var complexity:Int;
-}
+}
diff --git a/checkstyle/checks/MemberNameCheck.hx b/checkstyle/checks/MemberNameCheck.hx
@@ -47,6 +47,7 @@ class MemberNameCheck extends NameCheckBase {
 
 	function checkFields(d:Array<Field>) {
 		for (field in d) {
+			if (isCheckSuppressed (field)) continue;
 			switch (field.kind) {
 				case FVar (t, e):
 					checkField (field, t, e);
@@ -57,6 +58,7 @@ class MemberNameCheck extends NameCheckBase {
 
 	function checkTypedefFields(d:Array<Field>) {
 		for (field in d) {
+			if (isCheckSuppressed (field)) continue;
 			switch (field.kind) {
 				case FVar (t, e):
 					checkTypedefField (field, t, e);
diff --git a/checkstyle/checks/MethodLengthCheck.hx b/checkstyle/checks/MethodLengthCheck.hx
@@ -32,6 +32,7 @@ class MethodLengthCheck extends Check {
 
 	function searchFields(fs:Array<Field>){
 		for (f in fs) {
+			if (isCheckSuppressed (f)) continue;
 			switch(f.kind){
 			case FFun(ff):
 				checkMethod(f);
@@ -72,4 +73,4 @@ class MethodLengthCheck extends Check {
 	function _warnFunctionLength(name:String, pos:Int, ofs:Int) {
 		log('Function is too long: ${name} (> ${maxFunctionLines} lines, try splitting into multiple functions)', pos, ofs, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/checkstyle/checks/MethodNameCheck.hx b/checkstyle/checks/MethodNameCheck.hx
@@ -44,6 +44,7 @@ class MethodNameCheck extends NameCheckBase {
 
 	function checkFields(d:Array<Field>) {
 		for (field in d) {
+			if (isCheckSuppressed (field)) continue;
 			switch (field.kind) {
 				case FFun (f):
 					checkField (field);
diff --git a/checkstyle/checks/NestedForDepthCheck.hx b/checkstyle/checks/NestedForDepthCheck.hx
@@ -29,6 +29,7 @@ class NestedForDepthCheck extends Check {
 
 	function checkFields(d:Definition<ClassFlag, Array<Field>>) {
 		for (field in d.data) {
+			if (isCheckSuppressed (field)) continue;
 			checkField(field);
 		}
 	}
@@ -70,4 +71,4 @@ class NestedForDepthCheck extends Check {
 		logPos('Nested for depth is $depth (max allowed is ${max})',
 			pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/checkstyle/checks/NestedIfDepthCheck.hx b/checkstyle/checks/NestedIfDepthCheck.hx
@@ -29,6 +29,7 @@ class NestedIfDepthCheck extends Check {
 
 	function checkFields(d:Definition<ClassFlag, Array<Field>>) {
 		for (field in d.data) {
+			if (isCheckSuppressed (field)) continue;
 			checkField(field);
 		}
 	}
@@ -69,4 +70,4 @@ class NestedIfDepthCheck extends Check {
 		logPos('Nested if-else depth is $depth (max allowed is ${max})',
 			pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/checkstyle/checks/NestedTryDepthCheck.hx b/checkstyle/checks/NestedTryDepthCheck.hx
@@ -29,6 +29,7 @@ class NestedTryDepthCheck extends Check {
 
 	function checkFields(d:Definition<ClassFlag, Array<Field>>) {
 		for (field in d.data) {
+			if (isCheckSuppressed (field)) continue;
 			checkField(field);
 		}
 	}
@@ -75,4 +76,4 @@ class NestedTryDepthCheck extends Check {
 		logPos('Nested try depth is $depth (max allowed is ${max})',
 			pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/checkstyle/checks/ParameterNameCheck.hx b/checkstyle/checks/ParameterNameCheck.hx
@@ -40,6 +40,7 @@ class ParameterNameCheck extends NameCheckBase {
 
 	function checkFields(d:Array<Field>) {
 		for (field in d) {
+			if (isCheckSuppressed (field)) continue;
 			switch (field.kind) {
 				case FFun (f):
 					checkField (f.args, field.pos);
diff --git a/checkstyle/checks/ParameterNumberCheck.hx b/checkstyle/checks/ParameterNumberCheck.hx
@@ -30,6 +30,7 @@ class ParameterNumberCheck extends Check {
 
 	function checkField(f:Field) {
 		if (ignoreOverriddenMethods && f.access.indexOf(AOverride) >= 0) return;
+		if (isCheckSuppressed (f)) return;
 		switch (f.kind) {
 			case FFun(fun):
 				if ((fun.args != null) && (fun.args.length > max)) {
diff --git a/checkstyle/checks/PublicPrivateCheck.hx b/checkstyle/checks/PublicPrivateCheck.hx
@@ -23,6 +23,7 @@ class PublicPrivateCheck extends Check {
 
 	function checkFields(d:Definition<ClassFlag, Array<Field>>) {
 		for (field in d.data) {
+			if (isCheckSuppressed (field)) continue;
 			if (field.name != "new") {
 				if (d.flags.indexOf(HInterface) > -1) checkInterfaceField(field);
 				else checkField(field);
@@ -46,6 +47,7 @@ class PublicPrivateCheck extends Check {
 	}
 
 	function checkField(f:Field) {
+		if (isCheckSuppressed (f)) return;
 		if (enforcePublicPrivate) {
 			if ((f.access.indexOf(APublic) < 0) && (f.access.indexOf(APrivate) < 0)) {
 				_warnPrivateKeywordMissing(f.name, f.pos);
diff --git a/checkstyle/checks/ReturnCheck.hx b/checkstyle/checks/ReturnCheck.hx
@@ -24,6 +24,7 @@ class ReturnCheck extends Check {
 
 	function checkFields(d:Definition<ClassFlag, Array<Field>>) {
 		for (field in d.data) {
+			if (isCheckSuppressed (field)) continue;
 			if (field.name != "new" && d.flags.indexOf(HInterface) == -1) checkField(field);
 		}
 	}
diff --git a/checkstyle/checks/TypeCheck.hx b/checkstyle/checks/TypeCheck.hx
@@ -25,6 +25,7 @@ class TypeCheck extends Check {
 	}
 
 	function checkField(f:Field) {
+		if (isCheckSuppressed (f)) return;
 		switch(f.kind) {
 			case FVar(t, e):
 				if (t == null) _error(f.name, f.pos);
@@ -36,4 +37,4 @@ class TypeCheck extends Check {
 	function _error(name:String, pos:Position) {
 		logPos('Type not specified: ${name}', pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/checkstyle/checks/VariableInitialisationCheck.hx b/checkstyle/checks/VariableInitialisationCheck.hx
@@ -22,6 +22,7 @@ class VariableInitialisationCheck extends Check {
 
 	function checkFields(d:Definition<ClassFlag, Array<Field>>) {
 		for (field in d.data) {
+			if (isCheckSuppressed (field)) continue;
 			if (field.name != "new") {
 				if (d.flags.indexOf(HInterface) == -1) checkField(field);
 			}
@@ -57,4 +58,4 @@ class VariableInitialisationCheck extends Check {
 	function _warnVarinit(name:String, pos:Position) {
 		logPos('Invalid variable initialisation: ${name} (move initialisation to constructor or function)', pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+}
diff --git a/test/ConstantNameCheckTest.hx b/test/ConstantNameCheckTest.hx
@@ -69,6 +69,11 @@ class ConstantNameTests {
 		var Count4:Int = 1;
 		var count5:Int = 1;
 		var _count5:Int = 1;
+
+		@SuppressWarnings('checkstyle:ConstantName')
+		static inline var count6:Int = 1;
+		@SuppressWarnings('checkstyle:ConstantName')
+		static var count7:Int = 1;
 	}";
 
 	public static inline var TEST1:String = "
diff --git a/test/MemberNameCheckTest.hx b/test/MemberNameCheckTest.hx
@@ -106,6 +106,8 @@ class MemberNameTests {
 		static var COUNT:Int = 1;
 		static inline var COUNT2:Int = 1;
 		var count5:Int = 1;
+		@SuppressWarnings('checkstyle:MemberName')
+		var COUNT6:Int = 1;
 	}
 
 	enum Test2 {
@@ -116,6 +118,8 @@ class MemberNameTests {
 	typedef Test3 = {
 		var count1:Int;
 		var count2:String;
+		@SuppressWarnings('checkstyle:MemberName')
+		var COUNT6:Int = 1;
 	}";
 
 	public static inline var TEST1:String = "
diff --git a/test/MethodLengthCheckTest.hx b/test/MethodLengthCheckTest.hx
@@ -107,5 +107,20 @@ class MethodLengthTests {
 
 			tarce('TEST');
 		}
+
+		@SuppressWarnings('checkstyle:MethodLength')
+		public function test1() {
+			tarce('TEST');
+
+			tarce('TEST');
+
+			tarce('TEST');
+
+			tarce('TEST');
+
+			tarce('TEST');
+
+			tarce('TEST');
+		}
 	}";
-}
+}
diff --git a/test/MethodNameCheckTest.hx b/test/MethodNameCheckTest.hx
@@ -123,6 +123,10 @@ class MethodNameTests {
 		function testName() {}
 		public function testValue() {}
 		public function get_Test() {}
+		@SuppressWarnings('checkstyle:MethodName')
+		public function TEST() {}
+		@SuppressWarnings('checkstyle:MethodName')
+		function TEST2() {}
 	}
 	
 	typedef Test3 = {
diff --git a/test/NestedForDepthCheckTest.hx b/test/NestedForDepthCheckTest.hx
@@ -36,6 +36,19 @@ class NestedForDepthTests {
 				trace ('$i ${params[i]}');
 			}
 		}
+
+		@SuppressWarnings('checkstyle:NestedForDepth')
+		public function test2(param:Array<Int>) {
+			for (outerParam in params) {                      // level 0
+				for (middleParam in params) {                 // level 1
+					for (innerParam in params) {              // level 2
+						if (outerParam == innerParam) {
+							trace (param);
+						}
+					}
+				}
+			}
+		}
 	}";
 
 	public static inline var TEST2:String =
diff --git a/test/NestedIfDepthCheckTest.hx b/test/NestedIfDepthCheckTest.hx
@@ -39,6 +39,20 @@ class NestedIfDepthTests {
 				return 2;
 			}
 		}
+
+		@SuppressWarnings('checkstyle:NestedIfDepth')
+		public function test1(param:Int) {
+			if (param == 1) {                           // level 0
+				return 1;
+			}
+			else {
+				if ((param == 2) || (param == 3)) {     // level 1
+					if (param == 3) return 3;           // level 2
+					return 2;
+				}
+			}
+			return 3;
+		}
 	}";
 
 	public static inline var TEST2:String =
diff --git a/test/NestedTryDepthCheckTest.hx b/test/NestedTryDepthCheckTest.hx
diff --git a/test/ParameterNameCheckTest.hx b/test/ParameterNameCheckTest.hx
diff --git a/test/ParameterNumberCheckTest.hx b/test/ParameterNumberCheckTest.hx
diff --git a/test/TypeCheckTest.hx b/test/TypeCheckTest.hx
diff --git a/test/VariableInitialisationCheckTest.hx b/test/VariableInitialisationCheckTest.hx

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,10 @@ class AnonymousCheck extends Check {`
`19`	`19`	`for (td in _checker.ast.decls) {`
`20`	`20`	`switch (td.decl){`
`21`	`21`	`case EClass(d):`
`22`		`- for (field in d.data) if (field.name != "new") checkField(field);`
	`22`	`+ for (field in d.data) {`
	`23`	`+ if (isCheckSuppressed (field)) continue;`
	`24`	`+ if (field.name != "new") checkField(field);`
	`25`	`+ }`
`23`	`26`	`default:`
`24`	`27`	`}`
`25`	`28`	`}`
`@@ -42,4 +45,4 @@ class AnonymousCheck extends Check {`
`42`	`45`	`function _error(name:String, pos:Position) {`
`43`	`46`	`logPos('Anonymous structure found, it is advised to use a typedef instead \"${name}\"', pos, Reflect.field(SeverityLevel, severity));`
`44`	`47`	`}`
`45`		`-}`
	`48`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ class NestedForDepthCheck extends Check {`
`29`	`29`
`30`	`30`	`function checkFields(d:Definition<ClassFlag, Array<Field>>) {`
`31`	`31`	`for (field in d.data) {`
	`32`	`+ if (isCheckSuppressed (field)) continue;`
`32`	`33`	`checkField(field);`
`33`	`34`	`}`
`34`	`35`	`}`
`@@ -70,4 +71,4 @@ class NestedForDepthCheck extends Check {`
`70`	`71`	`logPos('Nested for depth is $depth (max allowed is ${max})',`
`71`	`72`	`pos, Reflect.field(SeverityLevel, severity));`
`72`	`73`	`}`
`73`		`-}`
	`74`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ class NestedIfDepthCheck extends Check {`
`29`	`29`
`30`	`30`	`function checkFields(d:Definition<ClassFlag, Array<Field>>) {`
`31`	`31`	`for (field in d.data) {`
	`32`	`+ if (isCheckSuppressed (field)) continue;`
`32`	`33`	`checkField(field);`
`33`	`34`	`}`
`34`	`35`	`}`
`@@ -69,4 +70,4 @@ class NestedIfDepthCheck extends Check {`
`69`	`70`	`logPos('Nested if-else depth is $depth (max allowed is ${max})',`
`70`	`71`	`pos, Reflect.field(SeverityLevel, severity));`
`71`	`72`	`}`
`72`		`-}`
	`73`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ class NestedTryDepthCheck extends Check {`
`29`	`29`
`30`	`30`	`function checkFields(d:Definition<ClassFlag, Array<Field>>) {`
`31`	`31`	`for (field in d.data) {`
	`32`	`+ if (isCheckSuppressed (field)) continue;`
`32`	`33`	`checkField(field);`
`33`	`34`	`}`
`34`	`35`	`}`
`@@ -75,4 +76,4 @@ class NestedTryDepthCheck extends Check {`
`75`	`76`	`logPos('Nested try depth is $depth (max allowed is ${max})',`
`76`	`77`	`pos, Reflect.field(SeverityLevel, severity));`
`77`	`78`	`}`
`78`		`-}`
	`79`	`+}`