From 3cfb4cbead124b676a663992e2c3e65dc7f2a61d Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Thu, 17 Mar 2016 02:49:49 +0100 Subject: [PATCH 01/18] WIP: started working on WhitespaceCheck, #135 --- checkstyle.json | 65 +++++ resources/default-config.json | 23 ++ .../checks/whitespace/WhitespaceCheck.hx | 205 ++++++++++++++ test/checks/whitespace/WhitespaceCheckTest.hx | 259 ++++++++++++++++++ 4 files changed, 552 insertions(+) create mode 100644 src/checkstyle/checks/whitespace/WhitespaceCheck.hx create mode 100644 test/checks/whitespace/WhitespaceCheckTest.hx diff --git a/checkstyle.json b/checkstyle.json index 05a13609..684a0ccf 100644 --- a/checkstyle.json +++ b/checkstyle.json @@ -538,6 +538,71 @@ }, "type": "VariableInitialisation" }, + { + "props": { + "mode": "Around", + "tokens": [ + "=>", + "Assign", + "Unary", + "Compare", + "Bitwise", + "Bool", + "{", + "}" + ], + "contexts": [ + "Object", + "Function", + "Field", + "Switch", + "Switch", + "Array" + ], + "severity": "WARNING" + }, + "type": "Whitespace" + }, + { + "props": { + "mode": "None", + "tokens": [ + ".", + ":", + "(", + ")" + ], + "contexts": [ + "Object", + "Function", + "Field", + "Switch", + "Switch", + "Array" + ], + "severity": "WARNING" + }, + "type": "Whitespace" + }, + { + "props": { + "mode": "After", + "tokens": [ + ",", + ";" + ], + "contexts": [ + "Object", + "Function", + "Field", + "Switch", + "Switch", + "Array" + ], + "severity": "WARNING" + }, + "type": "Whitespace" + }, { "props": { "tokens": [ diff --git a/resources/default-config.json b/resources/default-config.json index d1d8cd9f..833c3511 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -532,6 +532,29 @@ }, "type": "VariableInitialisation" }, + { + "props": { + "mode": "around", + "tokens": [ + "=>", + "Assign", + "Unary", + "Compare", + "Bitwise", + "Bool" + ], + "contexts": [ + "Object", + "Function", + "Field", + "Switch", + "Switch", + "Array" + ], + "severity": "IGNORE" + }, + "type": "Whitespace" + }, { "props": { "tokens": [ diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx new file mode 100644 index 00000000..761f018d --- /dev/null +++ b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx @@ -0,0 +1,205 @@ +package checkstyle.checks.whitespace; + +import checkstyle.Checker.LinePos; +import checkstyle.token.TokenTree; +import checkstyle.utils.TokenTreeCheckUtils; +import haxeparser.Data; +import haxe.macro.Expr; + +using checkstyle.utils.ArrayUtils; + +@name("Whitespace") +@desc("Checks that is present or absent around a token.") +class WhitespaceCheck extends Check { + + public var mode:WhitespaceMode; + public var tokens:Array; + public var contexts:Array; + + public function new() { + super(TOKEN); + tokens = [ + ARROW, ASSIGN, UNARY, COMPARE, BITWISE, BOOL + ]; + mode = AROUND; + contexts = [OBJECT_DECL, FUNCTION, FIELD, SWITCH, TRY_CATCH, ARRAY_ACCESS]; + + categories = [Category.STYLE, Category.CLARITY]; + } + + override function actualRun() { + var tokenList:Array = []; + + for (token in tokens) { + switch (token) { + case ASSIGN: + tokenList = tokenList.concat([ + Binop(OpAssign), + Binop(OpAssignOp(OpAdd)), + Binop(OpAssignOp(OpSub)), + Binop(OpAssignOp(OpMult)), + Binop(OpAssignOp(OpDiv)), + Binop(OpAssignOp(OpMod)), + Binop(OpAssignOp(OpShl)), + Binop(OpAssignOp(OpShr)), + Binop(OpAssignOp(OpUShr)), + Binop(OpAssignOp(OpOr)), + Binop(OpAssignOp(OpAnd)), + Binop(OpAssignOp(OpXor)) + ]); + case UNARY: + tokenList = tokenList.concat([ + Unop(OpNot), + Unop(OpIncrement), + Unop(OpDecrement) + ]); + case COMPARE: + tokenList = tokenList.concat([ + Binop(OpGt), + Binop(OpLt), + Binop(OpGte), + Binop(OpLte), + Binop(OpEq), + Binop(OpNotEq) + ]); + case ARITHMETIC: + tokenList = tokenList.concat([ + Binop(OpAdd), + Binop(OpSub), + Binop(OpMult), + Binop(OpDiv), + Binop(OpMod) + ]); + case BITWISE: + tokenList = tokenList.concat([ + Binop(OpAnd), + Binop(OpOr), + Binop(OpXor), + Binop(OpShl), + Binop(OpShr), + Binop(OpUShr) + ]); + case BOOL: + tokenList.push(Binop(OpBoolAnd)); + tokenList.push(Binop(OpBoolOr)); + case ARROW: + tokenList.push(Arrow); + case COMMA: + tokenList.push(Comma); + case SEMICOLON: + tokenList.push(Semicolon); + case POPEN: + tokenList.push(POpen); + case PCLOSE: + tokenList.push(PClose); + case BROPEN: + tokenList.push(BrOpen); + case BRCLOSE: + tokenList.push(BrClose); + case BKOPEN: + tokenList.push(BkOpen); + case BKCLOSE: + tokenList.push(BkClose); + case DBLDOT: + tokenList.push(DblDot); + case DOT: + tokenList.push(Dot); + case INTERVAL: + tokenList.push(Binop(OpInterval)); + } + } + + if (tokenList.length <= 0) return; + checkTokens(tokenList); + } + + function checkTokens(tokenList:Array) { + var root:TokenTree = checker.getTokenTree(); + var allTokens:Array = root.filter(tokenList, ALL); + + for (tok in allTokens) { + if (isPosSuppressed(tok.pos)) continue; + if (!checkContext(tok)) continue; + + checkWhitespace(tok); + } + } + + function checkWhitespace(tok:TokenTree) { + var linePos:LinePos = checker.getLinePos(tok.pos.min); + var line:String = checker.lines[linePos.line]; + var before:String = line.substr(0, linePos.ofs); + var tokLen:Int = TokenDefPrinter.print(tok.tok).length; + var after:String = line.substr(linePos.ofs + tokLen); + + var whitespaceBefore:Bool = ~/^(.*\s|)$/.match(before); + var whitespaceAfter:Bool = ~/^(\s.*|)$/.match(after); + + switch (mode) { + case BEFORE: + if (whitespaceBefore && !whitespaceAfter) return; + case AFTER: + if (!whitespaceBefore && whitespaceAfter) return; + case NONE: + if (!whitespaceBefore && !whitespaceAfter) return; + case AROUND: + if (whitespaceBefore && whitespaceAfter) return; + } + + logPos('Whitespace mode "$mode" violated by "${TokenDefPrinter.print(tok.tok)}"', tok.pos); + } + + function checkContext(token:TokenTree):Bool { + if (TokenTreeCheckUtils.isTypeParameter(token)) return false; + if (TokenTreeCheckUtils.isImportMult(token)) return false; + if (TokenTreeCheckUtils.filterOpSub(token)) return false; + + // TODO check contexts + + return true; + } + + function hasContext(context:WhitespaceContext):Bool { + return contexts.contains(context); + } +} + +@:enum +abstract WhitespaceMode(String) { + var BEFORE = "before"; + var AFTER = "after"; + var AROUND = "around"; + var NONE = "none"; +} + +@:enum +abstract WhitespaceContext(String) { + var OBJECT_DECL = "Object"; + var FUNCTION = "Function"; + var FIELD = "Field"; + var SWITCH = "Switch"; + var TRY_CATCH = "Switch"; + var ARRAY_ACCESS = "Array"; +} + +@:enum +abstract WhitespaceToken(String) { + var ASSIGN = "Assign"; + var UNARY = "Unary"; + var COMPARE = "Compare"; + var ARITHMETIC = "Arithmetic"; + var BITWISE = "Bitwise"; + var BOOL = "Bool"; + var ARROW = "=>"; + var COMMA = ","; + var SEMICOLON = ";"; + var POPEN = "("; + var PCLOSE = ")"; + var BROPEN = "{"; + var BRCLOSE = "}"; + var BKOPEN = "["; + var BKCLOSE = "]"; + var DBLDOT = ":"; + var DOT = "."; + var INTERVAL = "..."; +} \ No newline at end of file diff --git a/test/checks/whitespace/WhitespaceCheckTest.hx b/test/checks/whitespace/WhitespaceCheckTest.hx new file mode 100644 index 00000000..c3a039d8 --- /dev/null +++ b/test/checks/whitespace/WhitespaceCheckTest.hx @@ -0,0 +1,259 @@ +package checks.whitespace; + +import checkstyle.checks.whitespace.WhitespaceCheck; + +class WhitespaceCheckTest extends CheckTestCase { + + static inline var MSG_EQUALS:String = 'Whitespace mode "around" violated by "="'; + + public function testCorrectWhitespace() { + var check = new WhitespaceCheck(); + assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + assertNoMsg(check, ISSUE_70); + assertNoMsg(check, ISSUE_71); + assertNoMsg(check, ISSUE_72); + assertNoMsg(check, ISSUE_77); + assertNoMsg(check, ISSUE_80); + assertNoMsg(check, ISSUE_81); + assertNoMsg(check, ISSUE_98); + assertNoMsg(check, MINUS_CONSTANT); + assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); + assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); + assertNoMsg(check, CONDITIONAL_ELSEIF_STAR_IMPORT); + assertNoMsg(check, NEGATIVE_VARS); + assertNoMsg(check, NEGATIVE_NUMS); + assertNoMsg(check, OPGT); + } + + public function testIncorrectWhitespace() { + var check = new WhitespaceCheck(); + assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); + assertMsg(check, ISSUE_59, MSG_EQUALS); + assertMsg(check, ISSUE_63, MSG_EQUALS); + } + + public function testIncorrectWhitespaceToken() { + var check = new WhitespaceCheck(); + check.tokens = [ASSIGN]; + assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + assertMsg(check, NO_WHITESPACE_GT, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_VAR_INIT, MSG_EQUALS); + + check.tokens = [COMPARE]; + assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + assertNoMsg(check, NO_WHITESPACE_VAR_INIT); + assertNoMsg(check, NO_WHITESPACE_GT); + } + + public function testStarImport() { + var check = new WhitespaceCheck(); + check.tokens = [ARITHMETIC]; + assertNoMsg(check, ISSUE_70); + assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); + assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); + assertNoMsg(check, CONDITIONAL_ELSEIF_STAR_IMPORT); + } +} + +@:enum +abstract WhitespaceCheckTests(String) to String { + var CORRECT_WHITESPACE_AROUND = " + import haxe.macro.*; + + class Test { + function test(param1:String, param2:String) { + var x = { x: 100, y: 100, + z: 20 * 10 + }; + var y:Array = []; + } + } + + typedef Test = { + x:Int, + y:Int, z:Int + } + + enum Test { + Monday; + Tuesday; + Wednesday; + Thursday; + Friday; Weekend(day:String); + }"; + + var NO_WHITESPACE_OBJECT_DECL = " + class Test { + function test(param1:String, param2:String) { + var x={ x: 100, y: 100,z: 20 }; + } + }"; + + var NO_WHITESPACE_TYPEDEF = " + typedef Test ={ + x:Int, + y:Int,z:Int + }"; + + var NO_WHITESPACE_VAR_INIT = " + class Test { + function test(param1:String, param2:String) { + var test:Array=[]; + } + }"; + + var NO_WHITESPACE_GT = " + class Test { + function test(param1:String, param2:String) { + var test:Array= []; + } + }"; + + var ISSUE_58 = " + class Test { + public function new() { + var x:Int, y:Int; + } + }"; + + var ISSUE_59 = " + typedef Test=Int + "; + + var ISSUE_63 = " + typedef Test =#if true Int #else String #end + "; + + var ISSUE_70 = " + import haxe.macro.*; + "; + + var ISSUE_71 = " + class Test { + function foo() { + trace((null : Array)); + } + }"; + + var ISSUE_72 = " + abstract Test(Array) {} + "; + + var ISSUE_77 = " + // comment + class Test // comment + { // comment + function foo() // comment + { // comment + switch ('Test') // comment + { // comment + } // comment + } // comment + } // comment + "; + + var ISSUE_80 = " + interface Test implements Dynamic {} + "; + + var ISSUE_81 = " + class Test { + function foo() { + do a++ while (true); + do ++a while (true); + } + }"; + + var ISSUE_98 = " + class Test { + // °öäüßÖÄÜ@łĸŋđđðſðæµ”“„¢«»Ø→↓←Ŧ¶€Ł}][{¬½¼³² + var test:Int = 0; + }"; + + var MINUS_CONSTANT = " + class Test { + function test() { + if (re.match(line) && line.indexOf('//') == -1) { + log('Tab after non-space character, Use space for aligning', i + 1, line.length, null, Reflect.field(SeverityLevel, severity)); + return -1; + } + a = 1 - -2; + b = 1.2 - -2.1; + return -1; + } + }"; + + var CONDITIONAL_STAR_IMPORT_ISSUE_160 = " + #if macro + import haxe.macro.*; + #end"; + + var CONDITIONAL_ELSEIF_STAR_IMPORT = " + #if macro + import haxe.macro.Type; + #elseif neko + import haxe.macro.*; + #elseif neko + import haxe.macro.*; + #else + #if linux + import haxe.macro.Type; + #else + import haxe.macro.*; + #end + #end + import haxe.macro.Type;"; + + var CONDITIONAL_ELSE_STAR_IMPORT = " + #if macro + import haxe.macro.Type; + #else + import haxe.macro.*; + #end + import haxe.macro.Type;"; + + var NEGATIVE_VARS = " + class Test { + function test() { + var rest = if (neg) { -noFractions; } + else { -noFractions; } + var rest = if (neg) -noFractions; + else -noFractions; + var x = neg ? -frag : -frag; + calc ([-width, -node.right, root], -node.left, {x : -x, y: -y}); + (-a); + (1 * -a); + do -a * 2 while(true); + for (a in [-1, -2]) -a + 2; + return -a; + } + }"; + + var NEGATIVE_NUMS = " + class Test { + function test() { + var rest = if (neg) { -8; } + else { -9; } + var rest = if (neg) -10; + else -11; + var x = neg ? -12 : -13; + calc ([-14, -node.right, root], -node.left, {x : -xi15x, y: -16}); + (-16); + (1 * -17); + do -18 * 2 while(true); + for (a in [-1, -2]) -18 + 2; + } + }"; + + var OPGT = " + class Test { + function test() { + if (a > b) return a >= b; + if (a >> b > c) return a >>= b; + if (a >>> b > c) return a >>>= b; + } + }"; +} \ No newline at end of file From 2a3ed4a57038abd5696720d7c42b768a7eb20da1 Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Thu, 17 Mar 2016 10:40:26 +0100 Subject: [PATCH 02/18] WIP --- .../checks/whitespace/WhitespaceCheck.hx | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx index 761f018d..e779b871 100644 --- a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx @@ -150,15 +150,38 @@ class WhitespaceCheck extends Check { } function checkContext(token:TokenTree):Bool { - if (TokenTreeCheckUtils.isTypeParameter(token)) return false; if (TokenTreeCheckUtils.isImportMult(token)) return false; if (TokenTreeCheckUtils.filterOpSub(token)) return false; + if (TokenTreeCheckUtils.isTypeParameter(token)) { + return hasContext(TYPE_PARAMETER); + } + if (!hasContext(FUNCTION)) { + if (isFunctionContext(token)) return true; + } // TODO check contexts return true; } + function isFunctionContext(tok:TokenTree):Bool { + switch (tok.tok) { + case POpen, PClose, DblDot, Dot, Comma, BrOpen, BrClose: + case Binop(OpGt), Binop(OpLt), Binop(OpAssign): + default: return false; + } + var parent:TokenTree = tok.parent; + while (parent.tok != null) { + switch (parent.tok) { + case Kwd(KwdFunction): return true; + case Kwd(_): return false; + default: + } + parent = parent.parent; + } + return false; + } + function hasContext(context:WhitespaceContext):Bool { return contexts.contains(context); } @@ -180,6 +203,8 @@ abstract WhitespaceContext(String) { var SWITCH = "Switch"; var TRY_CATCH = "Switch"; var ARRAY_ACCESS = "Array"; + var REIFICATION = "Reification"; + var TYPE_PARAMETER = "TypeParameter"; } @:enum From 12b6e6f3d7d580014cdab206f93655db70129378 Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Thu, 17 Mar 2016 13:46:33 +0100 Subject: [PATCH 03/18] WIP still playing around with context detection --- checkstyle.json | 6 +- resources/default-config.json | 8 +- .../checks/whitespace/WhitespaceCheck.hx | 83 ++++++++++++++++++- 3 files changed, 92 insertions(+), 5 deletions(-) diff --git a/checkstyle.json b/checkstyle.json index 684a0ccf..fc4df7b4 100644 --- a/checkstyle.json +++ b/checkstyle.json @@ -540,7 +540,7 @@ }, { "props": { - "mode": "Around", + "mode": "around", "tokens": [ "=>", "Assign", @@ -565,7 +565,7 @@ }, { "props": { - "mode": "None", + "mode": "none", "tokens": [ ".", ":", @@ -586,7 +586,7 @@ }, { "props": { - "mode": "After", + "mode": "after", "tokens": [ ",", ";" diff --git a/resources/default-config.json b/resources/default-config.json index 833c3511..d29774e6 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -549,7 +549,13 @@ "Field", "Switch", "Switch", - "Array" + "Array", + "Block", + "Class", + "Interface", + "Typedef", + "Abstract", + "Enum" ], "severity": "IGNORE" }, diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx index e779b871..c0114bcc 100644 --- a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx @@ -22,7 +22,7 @@ class WhitespaceCheck extends Check { ARROW, ASSIGN, UNARY, COMPARE, BITWISE, BOOL ]; mode = AROUND; - contexts = [OBJECT_DECL, FUNCTION, FIELD, SWITCH, TRY_CATCH, ARRAY_ACCESS]; + contexts = [OBJECT_DECL, FUNCTION, FIELD, SWITCH, TRY_CATCH, ARRAY_ACCESS, BLOCK, CLASS, INTERFACE, TYPEDEF, ABSTRACT, ENUM]; categories = [Category.STYLE, Category.CLARITY]; } @@ -150,15 +150,24 @@ class WhitespaceCheck extends Check { } function checkContext(token:TokenTree):Bool { + // TODO also handle package and using if (TokenTreeCheckUtils.isImportMult(token)) return false; if (TokenTreeCheckUtils.filterOpSub(token)) return false; + var currentContext:WhitespaceContext = determineContext(token); + if (currentContext == null || !hasContext(currentContext)) return false; + if (TokenTreeCheckUtils.isTypeParameter(token)) { return hasContext(TYPE_PARAMETER); } if (!hasContext(FUNCTION)) { if (isFunctionContext(token)) return true; } + switch (token.tok) { + case Dot: + case DblDot: + default: + } // TODO check contexts return true; @@ -182,6 +191,67 @@ class WhitespaceCheck extends Check { return false; } + function determineContext(token:TokenTree):WhitespaceContext { + while (token.tok != null) { + switch (token.tok) { + case At: return META; + case Dollar(_): return REIFICATION; + case Kwd(KwdClass): return CLASS; + case Kwd(KwdInterface): return INTERFACE; + case Kwd(KwdEnum): return ENUM; + case Kwd(KwdAbstract): return ABSTRACT; + case Kwd(KwdTypedef): return TYPEDEF; + case Kwd(KwdCase), Kwd(KwdDefault), Kwd(KwdSwitch): return SWITCH; + case Kwd(KwdCatch): return TRY_CATCH; + + case Kwd(KwdIf), Kwd(KwdElse): return SINGLELINE; + case Kwd(KwdDo): return SINGLELINE; + case Kwd(KwdFor): return SINGLELINE; + case Kwd(KwdWhile): return SINGLELINE; + case Kwd(KwdFunction): return SINGLELINE; + case BkOpen: return ARRAY_ACCESS; + case BrOpen: return contextOfBrOpen(token.parent); + case POpen: return contextOfPOpen(token.parent); + case Binop(OpLt): + if (TokenTreeCheckUtils.isTypeParameter(token)) return TYPE_PARAMETER; + default: + } + token = token.parent; + } + + return null; + } + + function contextOfBrOpen(token:TokenTree):WhitespaceContext { + while (token.tok != null) { + switch (token.tok) { + case Kwd(_): return BLOCK; + case POpen: return OBJECT_DECL; + case Comma: return OBJECT_DECL; + case BrOpen: return contextOfBrOpen(token.parent); + case Binop(OpAssign), Binop(OpAssignOp(_)): return OBJECT_DECL; + default: + } + token = token.parent; + } + return null; + } + + function contextOfPOpen(token:TokenTree):WhitespaceContext { + while (token.tok != null) { + switch (token.tok) { + case Kwd(KwdFunction): return FUNCTION; + case POpen: return contextOfPOpen(token); + case Binop(OpAssign), Binop(OpAssignOp(_)): return COND; + case Kwd(KwdVar): return PROPERTY; + case Kwd(KwdIf), Kwd(KwdFor), Kwd(KwdWhile), Kwd(KwdSwitch), Kwd(KwdCase): return COND; + default: + } + token = token.parent; + } + return null; + } + function hasContext(context:WhitespaceContext):Bool { return contexts.contains(context); } @@ -198,13 +268,24 @@ abstract WhitespaceMode(String) { @:enum abstract WhitespaceContext(String) { var OBJECT_DECL = "Object"; + var CLASS = "Class"; + var INTERFACE = "Interface"; + var TYPEDEF = "Typedef"; + var ABSTRACT = "Abstract"; + var ENUM = "Enum"; var FUNCTION = "Function"; var FIELD = "Field"; + var PROPERTY = "Property"; + var BLOCK = "Block"; + var IF = "If"; + var COND = "Condition"; var SWITCH = "Switch"; var TRY_CATCH = "Switch"; var ARRAY_ACCESS = "Array"; var REIFICATION = "Reification"; var TYPE_PARAMETER = "TypeParameter"; + var META = "Meta"; + var SINGLELINE = "Singleline"; } @:enum From 6c827fec3250e458a993857ff004fda75f1fadb1 Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 12:28:00 +0000 Subject: [PATCH 04/18] added more multiline strings --- test/checks/whitespace/EmptyLinesCheckTest.hx | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/test/checks/whitespace/EmptyLinesCheckTest.hx b/test/checks/whitespace/EmptyLinesCheckTest.hx index fbc13742..a719b1bc 100644 --- a/test/checks/whitespace/EmptyLinesCheckTest.hx +++ b/test/checks/whitespace/EmptyLinesCheckTest.hx @@ -85,7 +85,25 @@ abstract EmptyLinesCheckTests(String) to String { var b:Int; - var b:String = ' multistring + var c:String = ' multistring + + + + '; + + var d:String = ' multistring; \" + + + + '; + + var e:String = ' multistring; \"\' + + var t=1; + + + + var s=''; From 08333c502a7b4eb6d56bc288b484c5e166ff1a2e Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 12:28:19 +0000 Subject: [PATCH 05/18] added test to check TODO in string --- test/checks/comments/TODOCommentCheckTest.hx | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/test/checks/comments/TODOCommentCheckTest.hx b/test/checks/comments/TODOCommentCheckTest.hx index 000ee6d4..6b773530 100644 --- a/test/checks/comments/TODOCommentCheckTest.hx +++ b/test/checks/comments/TODOCommentCheckTest.hx @@ -23,6 +23,10 @@ class TODOCommentCheckTest extends CheckTestCase { public function testXXX() { assertMsg(new TODOCommentCheck(), TEST5, "TODO comment: XXX remove test"); } + + public function testString() { + assertNoMsg(new TODOCommentCheck(), TEST6); + } } @:enum @@ -56,4 +60,10 @@ abstract TODOCommentCheckTests(String) to String { // XXX remove test public override function test() {} }"; + + var TEST6 = " + class Test { + var a:String = 'TODO: remove test'; + public override function test() {} + }"; } \ No newline at end of file From 1a96f7d5436b7bde6f268753bbef13286bf552bb Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 12:28:35 +0000 Subject: [PATCH 06/18] unused import --- src/checkstyle/checks/whitespace/WrapCheckBase.hx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/checkstyle/checks/whitespace/WrapCheckBase.hx b/src/checkstyle/checks/whitespace/WrapCheckBase.hx index 62bfc600..046c7554 100644 --- a/src/checkstyle/checks/whitespace/WrapCheckBase.hx +++ b/src/checkstyle/checks/whitespace/WrapCheckBase.hx @@ -4,7 +4,6 @@ import checkstyle.Checker.LinePos; import checkstyle.token.TokenTree; import checkstyle.utils.TokenTreeCheckUtils; import haxeparser.Data; -import haxe.macro.Expr; using checkstyle.utils.ArrayUtils; From 3cccf0bd54935e05cc37334863f8ebccdc17faaa Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 12:49:07 +0000 Subject: [PATCH 07/18] base class for whitespace line checks --- .../checks/whitespace/LineCheckBase.hx | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 src/checkstyle/checks/whitespace/LineCheckBase.hx diff --git a/src/checkstyle/checks/whitespace/LineCheckBase.hx b/src/checkstyle/checks/whitespace/LineCheckBase.hx new file mode 100644 index 00000000..23069b02 --- /dev/null +++ b/src/checkstyle/checks/whitespace/LineCheckBase.hx @@ -0,0 +1,34 @@ +package checkstyle.checks.whitespace; + +@ignore("base class line based whitespace checks") +class LineCheckBase extends Check { + + var quotesRE:EReg; + var multilineStartRE:EReg; + var escapeRE:EReg; + var multilineStringStart:Bool; + + public function new() { + super(LINE); + quotesRE = ~/('|")/; + multilineStartRE = null; + escapeRE = null; + multilineStringStart = false; + } + + function isMultineString(line:String):Bool { + if (!multilineStringStart && quotesRE.match(line)) { + var matched = quotesRE.matched(0); + var matchedRight = quotesRE.matchedRight(); + multilineStartRE = new EReg(matched, ""); + escapeRE = new EReg("\\" + matched, ""); + multilineStringStart = !multilineStartRE.match(matchedRight) && !escapeRE.match(matchedRight); + } + else if (multilineStringStart && multilineStartRE != null && multilineStartRE.match(line) && !escapeRE.match(line)) { + multilineStringStart = false; + multilineStartRE = null; + escapeRE = null; + } + return multilineStringStart; + } +} \ No newline at end of file From a962dc72b3788712d978bb87cf6c8b06807de10a Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 12:49:39 +0000 Subject: [PATCH 08/18] removed excludes related to multiline strings --- checkstyle-exclude.json | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/checkstyle-exclude.json b/checkstyle-exclude.json index 4ccb0f3b..aaefb642 100644 --- a/checkstyle-exclude.json +++ b/checkstyle-exclude.json @@ -6,9 +6,6 @@ "checkstyle.ChecksInfo", "checkstyle.checks.imports.UnusedImportCheck" ], - "EmptyLines": [ - "checks.whitespace.EmptyLinesCheckTest" - ], "MultipleStringLiterals": [ "checks", "token" @@ -17,17 +14,6 @@ "checkstyle.checks.coding.MultipleVariableDeclarationsCheck", "checks.coding.MultipleVariableDeclarationsCheckTest" ], - "TrailingWhitespace": [ - "checks.whitespace.SpacingCheckTest", - "checks.whitespace.TrailingWhitespaceCheckTest", - "checks.naming.MemberNameCheckTest" - ], - "TabForAligning": [ - "checks.whitespace.TabForAligningCheckTest" - ], - "IndentationCharacter": [ - "checks.whitespace.IndentationCharacterCheckTest" - ], "CyclomaticComplexity": [ "checkstyle.checks.Check", "checkstyle.utils.ExprUtils", @@ -56,9 +42,6 @@ "checkstyle.checks.whitespace.EmptyLinesCheck", "checkstyle.token.TokenTreeBuilder" ], - "MagicNumber": [ - "checkstyle.reporter.ProgressReporter" - ], "NestedForDepth": [ "TestMain" ], From b167b2df91e43ae4405203a183dd4b97d8b20281 Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 13:07:08 +0000 Subject: [PATCH 09/18] cleanup --- checkstyle.json | 2 +- src/checkstyle/Main.hx | 8 +++++--- src/checkstyle/checks/Check.hx | 4 +--- .../checks/coding/MultipleVariableDeclarationsCheck.hx | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/checkstyle.json b/checkstyle.json index fc4df7b4..bbe23518 100644 --- a/checkstyle.json +++ b/checkstyle.json @@ -210,7 +210,7 @@ }, { "props": { - "ignoreNumbers": [-1, 0, 1, 2, 3, 5, 8, 13, 21, 34], + "ignoreNumbers": [-1, 0, 1, 2, 3, 5, 8, 13, 21, 34, 100], "severity": "INFO" }, "type": "MagicNumber" diff --git a/src/checkstyle/Main.hx b/src/checkstyle/Main.hx index 10aeeac1..ea88fc83 100644 --- a/src/checkstyle/Main.hx +++ b/src/checkstyle/Main.hx @@ -171,7 +171,6 @@ class Main { function setCheckProperties(check:Check, checkConf:CheckConfig, defaultSeverity:SeverityLevel) { validateAllowedFields(checkConf, ["type", "props"], check.getModuleName()); - var props = (checkConf.props == null) ? [] : Reflect.fields(checkConf.props); // use Type.getInstanceFields to make it work in c++ / profiler var checkFields:Array = Type.getInstanceFields(Type.getClass(check)); @@ -248,8 +247,11 @@ class Main { function generateDefaultConfig(path) { addAllChecks(); - - var propsNotAllowed:Array = ["moduleName", "severity", "type", "categories", "points", "desc"]; + var propsNotAllowed:Array = [ + "moduleName", "severity", "type", "categories", + "points", "desc", "quotesRE", "multilineStartRE", + "escapeRE", "multilineStringStart" + ]; var config = getEmptyConfig(); for (check in checker.checks) { var checkConfig:CheckConfig = { diff --git a/src/checkstyle/checks/Check.hx b/src/checkstyle/checks/Check.hx index 13f5ef1d..93ad7309 100644 --- a/src/checkstyle/checks/Check.hx +++ b/src/checkstyle/checks/Check.hx @@ -36,9 +36,7 @@ class Check { try { actualRun(); } - catch (e:String) { - //exception - } + catch (e:String) {} } return messages; } diff --git a/src/checkstyle/checks/coding/MultipleVariableDeclarationsCheck.hx b/src/checkstyle/checks/coding/MultipleVariableDeclarationsCheck.hx index 10a473b6..ee890fd7 100644 --- a/src/checkstyle/checks/coding/MultipleVariableDeclarationsCheck.hx +++ b/src/checkstyle/checks/coding/MultipleVariableDeclarationsCheck.hx @@ -26,7 +26,7 @@ class MultipleVariableDeclarationsCheck extends Check { default: } } - if (count > 1) logPos('Each variable declaration must be in its own statement', v.pos); + if (count > 1) logPos("Each variable declaration must be in its own statement", v.pos); } // Need line no of each token to remove line based check From 0ee06755ce3ef59b2ebb8bd55c9335dd0b852a3a Mon Sep 17 00:00:00 2001 From: Adi Date: Thu, 17 Mar 2016 13:07:27 +0000 Subject: [PATCH 10/18] fixes #195 --- src/checkstyle/checks/whitespace/EmptyLinesCheck.hx | 13 ++++--------- .../checks/whitespace/IndentationCharacterCheck.hx | 5 +++-- .../checks/whitespace/TabForAligningCheck.hx | 5 +++-- .../checks/whitespace/TrailingWhitespaceCheck.hx | 7 ++----- 4 files changed, 12 insertions(+), 18 deletions(-) diff --git a/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx b/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx index 55afb440..03ab075b 100644 --- a/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx +++ b/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx @@ -4,7 +4,7 @@ using StringTools; @name("EmptyLines") @desc("Checks for consecutive empty lines (default is 1). Also have options to check empty line separators after package, single-line and multi-line comments and class/interface/abstract declarations.") -class EmptyLinesCheck extends Check { +class EmptyLinesCheck extends LineCheckBase { public var max:Int; public var allowEmptyLineAfterSingleLineComment:Bool; @@ -15,7 +15,7 @@ class EmptyLinesCheck extends Check { public var requireEmptyLineAfterAbstract:Bool; public function new() { - super(LINE); + super(); max = 1; allowEmptyLineAfterSingleLineComment = true; allowEmptyLineAfterMultiLineComment = true; @@ -27,7 +27,6 @@ class EmptyLinesCheck extends Check { } override function actualRun() { - var quotesRE = ~/('|")/; var inGroup = false; var isLastLinePackage = false; var isLastLineClass = false; @@ -35,12 +34,10 @@ class EmptyLinesCheck extends Check { var isLastLineAbstract = false; var start = 0; var end = 0; - var multilineStringStart = false; - var multilineStartRE:EReg = null; + for (i in 0 ... checker.lines.length) { var line = checker.lines[i]; - if (multilineStringStart && (multilineStartRE.match(line) || ~/.*;$/.match(line))) multilineStringStart = false; - if (multilineStringStart) continue; + if (isMultineString(line)) continue; if (~/^\s*$/.match(line)) { if (!inGroup) { inGroup = true; @@ -74,8 +71,6 @@ class EmptyLinesCheck extends Check { isLastLineClass = ~/^\s*class\s.*?\{/.match(line); isLastLineInterface = ~/^\s*interface\s.*?\{/.match(line); isLastLineAbstract = ~/^\s*abstract\s.*?\{/.match(line); - multilineStringStart = quotesRE.match(line) && !~/.*;$/.match(line); - if (multilineStringStart) multilineStartRE = new EReg(quotesRE.matched(0), ""); } if (inGroup) { diff --git a/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx b/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx index c6930831..ded25cb4 100644 --- a/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx +++ b/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx @@ -2,13 +2,13 @@ package checkstyle.checks.whitespace; @name("IndentationCharacter") @desc("Checks indentation character (tab/space, default is tab).") -class IndentationCharacterCheck extends Check { +class IndentationCharacterCheck extends LineCheckBase { public var character:IndentationCharacterCheckCharacter; public var ignorePattern:String; public function new() { - super(LINE); + super(); character = TAB; ignorePattern = "^$"; } @@ -19,6 +19,7 @@ class IndentationCharacterCheck extends Check { for (i in 0 ... checker.lines.length) { var line = checker.lines[i]; if (ignoreRE.match(line) || isLineSuppressed(i)) continue; + if (isMultineString(line)) continue; if (line.length > 0 && !re.match(line)) log('Wrong indentation character (should be ${character})', i + 1, 0); } } diff --git a/src/checkstyle/checks/whitespace/TabForAligningCheck.hx b/src/checkstyle/checks/whitespace/TabForAligningCheck.hx index cc6db702..267482ed 100644 --- a/src/checkstyle/checks/whitespace/TabForAligningCheck.hx +++ b/src/checkstyle/checks/whitespace/TabForAligningCheck.hx @@ -4,12 +4,12 @@ using checkstyle.utils.StringUtils; @name("TabForAligning") @desc("Checks if there are any tabs in the middle of a line.") -class TabForAligningCheck extends Check { +class TabForAligningCheck extends LineCheckBase { public var ignorePattern:String; public function new() { - super(LINE); + super(); ignorePattern = "^$"; categories = [Category.STYLE, Category.CLARITY]; } @@ -20,6 +20,7 @@ class TabForAligningCheck extends Check { for (i in 0 ... checker.lines.length) { var line = checker.lines[i]; if (ignoreRE.match(line)) continue; + if (isMultineString(line)) continue; if (re.match(line)) log("Tab after non-space character, use space for aligning", i + 1, line.length); } } diff --git a/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx b/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx index 5ba53b98..eb6660e6 100644 --- a/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx @@ -2,16 +2,13 @@ package checkstyle.checks.whitespace; @name("TrailingWhitespace") @desc("Checks if there are any trailing white spaces.") -class TrailingWhitespaceCheck extends Check { - - public function new() { - super(LINE); - } +class TrailingWhitespaceCheck extends LineCheckBase { override function actualRun() { var re = ~/\s+$/; for (i in 0 ... checker.lines.length) { var line = checker.lines[i]; + if (isMultineString(line)) continue; if (re.match(line)) log("Trailing whitespace", i + 1, line.length); } } From 140e22387544fba71e39c6cf310dbfbf48573c69 Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Fri, 18 Mar 2016 12:38:00 +0100 Subject: [PATCH 11/18] extracted OperatorWhitespaceCheck --- checkstyle.json | 78 ++------ resources/default-config.json | 13 ++ .../whitespace/OperatorWhitespaceCheck.hx | 185 ++++++++++++++++++ .../checks/whitespace/WhitespaceCheck.hx | 21 +- 4 files changed, 226 insertions(+), 71 deletions(-) create mode 100644 src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx diff --git a/checkstyle.json b/checkstyle.json index 81a1c70c..34b27058 100644 --- a/checkstyle.json +++ b/checkstyle.json @@ -335,6 +335,19 @@ }, "type": "NestedTryDepth" }, + { + "props": { + "assignOpPolicy": "around", + "unaryOpPolicy": "ignore", + "arithmeticOpPolicy": "around", + "compareOpPolicy": "around", + "bitwiseOpPolicy": "around", + "boolOpPolicy": "around", + "intervalOpPolicy": "none", + "severity": "INFO" + }, + "type": "OperatorWhitespace" + }, { "props": { "tokens": [ @@ -553,71 +566,6 @@ }, "type": "VariableInitialisation" }, - { - "props": { - "mode": "around", - "tokens": [ - "=>", - "Assign", - "Unary", - "Compare", - "Bitwise", - "Bool", - "{", - "}" - ], - "contexts": [ - "Object", - "Function", - "Field", - "Switch", - "Switch", - "Array" - ], - "severity": "WARNING" - }, - "type": "Whitespace" - }, - { - "props": { - "mode": "none", - "tokens": [ - ".", - ":", - "(", - ")" - ], - "contexts": [ - "Object", - "Function", - "Field", - "Switch", - "Switch", - "Array" - ], - "severity": "WARNING" - }, - "type": "Whitespace" - }, - { - "props": { - "mode": "after", - "tokens": [ - ",", - ";" - ], - "contexts": [ - "Object", - "Function", - "Field", - "Switch", - "Switch", - "Array" - ], - "severity": "WARNING" - }, - "type": "Whitespace" - }, { "props": { "tokens": [ diff --git a/resources/default-config.json b/resources/default-config.json index b37805fd..41ff43df 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -342,6 +342,19 @@ }, "type": "NullableParameter" }, + { + "props": { + "unaryOpPolicy": "ignore", + "boolOpPolicy": "around", + "intervalOpPolicy": "none", + "assignOpPolicy": "around", + "bitwiseOpPolicy": "around", + "arithmeticOpPolicy": "around", + "compareOpPolicy": "around", + "severity": "IGNORE" + }, + "type": "OperatorWhitespace" + }, { "props": { "tokens": [ diff --git a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx new file mode 100644 index 00000000..a7267368 --- /dev/null +++ b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx @@ -0,0 +1,185 @@ +package checkstyle.checks.whitespace; + +import checkstyle.Checker.LinePos; +import checkstyle.token.TokenTree; +import checkstyle.utils.TokenTreeCheckUtils; +import checkstyle.checks.whitespace.WhitespaceCheck.WhitespacePolicy; +import haxeparser.Data; +import haxe.macro.Expr; + +using checkstyle.utils.ArrayUtils; + +@name("OperatorWhitespace") +@desc("Checks that is present or absent around a operators.") +class OperatorWhitespaceCheck extends Check { + + // =, +=, -=, *=, /=, <<=, >>=, >>>=, &=, |=, ^= + public var assignOpPolicy:WhitespacePolicy; + // ++, --, ! + public var unaryOpPolicy:WhitespacePolicy; + // +, -, *, /, % + public var arithmeticOpPolicy:WhitespacePolicy; + // ==, !=, <, <=, >, >= + public var compareOpPolicy:WhitespacePolicy; + // ~, &, |, ^, <<, >>, >>> + public var bitwiseOpPolicy:WhitespacePolicy; + // &&, || + public var boolOpPolicy:WhitespacePolicy; + // ... + public var intervalOpPolicy:WhitespacePolicy; + + public function new() { + super(TOKEN); + assignOpPolicy = AROUND; + unaryOpPolicy = IGNORE; + arithmeticOpPolicy = AROUND; + compareOpPolicy = AROUND; + bitwiseOpPolicy = AROUND; + boolOpPolicy = AROUND; + intervalOpPolicy = NONE; + + categories = [Category.STYLE, Category.CLARITY]; + } + + override function actualRun() { + var root:TokenTree = checker.getTokenTree(); + + checkAssignOps(root); + // TODO figure out Unary + //checkUnaryOps(root); + checkArithmeticOps(root); + checkCompareOps(root); + checkBitwiseOps(root); + checkBoolOps(root); + checkIntervalOps(root); + } + + function checkAssignOps(root:TokenTree) { + if ((assignOpPolicy == null) || (assignOpPolicy == IGNORE)) return; + var tokens:Array = root.filter([ + Binop(OpAssign), + Binop(OpAssignOp(OpAdd)), + Binop(OpAssignOp(OpSub)), + Binop(OpAssignOp(OpMult)), + Binop(OpAssignOp(OpDiv)), + Binop(OpAssignOp(OpMod)), + Binop(OpAssignOp(OpShl)), + Binop(OpAssignOp(OpShr)), + Binop(OpAssignOp(OpUShr)), + Binop(OpAssignOp(OpOr)), + Binop(OpAssignOp(OpAnd)), + Binop(OpAssignOp(OpXor)) + ], ALL); + + checkTokenList(tokens, assignOpPolicy); + } + + function checkUnaryOps(root:TokenTree) { + if ((unaryOpPolicy == null) || (unaryOpPolicy == IGNORE)) return; + var tokens:Array = root.filter([ + Unop(OpNot), + Unop(OpIncrement), + Unop(OpDecrement) + ], ALL); + checkTokenList(tokens, unaryOpPolicy); + } + + function checkArithmeticOps(root:TokenTree) { + if ((arithmeticOpPolicy == null) || (arithmeticOpPolicy == IGNORE)) return; + var tokens:Array = root.filter([ + Binop(OpAdd), + Binop(OpSub), + Binop(OpMult), + Binop(OpDiv), + Binop(OpMod) + ], ALL); + checkTokenList(tokens, arithmeticOpPolicy); + } + + function checkCompareOps(root:TokenTree) { + if ((compareOpPolicy == null) || (compareOpPolicy == IGNORE)) return; + var tokens:Array = root.filter([ + Binop(OpGt), + Binop(OpLt), + Binop(OpGte), + Binop(OpLte), + Binop(OpEq), + Binop(OpNotEq) + ], ALL); + checkTokenList(tokens, compareOpPolicy); + } + + function checkBitwiseOps(root:TokenTree) { + if ((bitwiseOpPolicy == null) || (bitwiseOpPolicy == IGNORE)) return; + var tokens:Array = root.filter([ + Binop(OpAnd), + Binop(OpOr), + Binop(OpXor), + Binop(OpShl), + Binop(OpShr), + Binop(OpUShr) + ], ALL); + checkTokenList(tokens, bitwiseOpPolicy); + } + + function checkBoolOps(root:TokenTree) { + if ((boolOpPolicy == null) || (boolOpPolicy == IGNORE)) return; + var tokens:Array = root.filter([ + Binop(OpBoolAnd), + Binop(OpBoolOr) + ], ALL); + checkTokenList(tokens, boolOpPolicy); + } + + function checkIntervalOps(root:TokenTree) { + if ((intervalOpPolicy == null) || (intervalOpPolicy == IGNORE)) return; + var tokens:Array = root.filterCallback(function(token:TokenTree, depth:Int):FilterResult { + if (token.tok == null) return GO_DEEPER; + return switch (token.tok) { + case Binop(OpInterval): FOUND_SKIP_SUBTREE; + case IntInterval(_): FOUND_SKIP_SUBTREE; + default: GO_DEEPER; + } + }); + checkTokenList(tokens, intervalOpPolicy); + } + + function checkTokenList(tokens:Array, policy:WhitespacePolicy) { + for (token in tokens) { + if (isPosSuppressed(token.pos)) continue; + if (TokenTreeCheckUtils.isTypeParameter(token)) continue; + checkWhitespace(token, policy); + } + } + + function checkWhitespace(tok:TokenTree, policy:WhitespacePolicy) { + var linePos:LinePos = checker.getLinePos(tok.pos.min); + if (tok.tok.match(IntInterval(_))) { + linePos = checker.getLinePos(tok.pos.max - 3); + } + var line:String = checker.lines[linePos.line]; + var before:String = line.substr(0, linePos.ofs); + var tokLen:Int = TokenDefPrinter.print(tok.tok).length; + var after:String = line.substr(linePos.ofs + tokLen); + + var whitespaceBefore:Bool = ~/^(.*\s|)$/.match(before); + var whitespaceAfter:Bool = ~/^(\s.*|)$/.match(after); + + switch (policy) { + case BEFORE: + if (whitespaceBefore && !whitespaceAfter) return; + case AFTER: + if (!whitespaceBefore && whitespaceAfter) return; + case NONE: + if (!whitespaceBefore && !whitespaceAfter) return; + case AROUND: + if (whitespaceBefore && whitespaceAfter) return; + case IGNORE: + return; + default: + return; + } + + logPos('OperatorWhitespace policy "$policy" violated by "${TokenDefPrinter.print(tok.tok)}"', tok.pos); + } +} diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx index c0114bcc..d192f268 100644 --- a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx @@ -157,12 +157,12 @@ class WhitespaceCheck extends Check { var currentContext:WhitespaceContext = determineContext(token); if (currentContext == null || !hasContext(currentContext)) return false; - if (TokenTreeCheckUtils.isTypeParameter(token)) { - return hasContext(TYPE_PARAMETER); - } - if (!hasContext(FUNCTION)) { - if (isFunctionContext(token)) return true; - } + //if (TokenTreeCheckUtils.isTypeParameter(token)) { + // return hasContext(TYPE_PARAMETER); + //} + //if (!hasContext(FUNCTION)) { + // if (isFunctionContext(token)) return true; + //} switch (token.tok) { case Dot: case DblDot: @@ -308,4 +308,13 @@ abstract WhitespaceToken(String) { var DBLDOT = ":"; var DOT = "."; var INTERVAL = "..."; +} + +@:enum +abstract WhitespacePolicy(String) { + var BEFORE = "before"; + var AFTER = "after"; + var AROUND = "around"; + var NONE = "none"; + var IGNORE = "ignore"; } \ No newline at end of file From 4afef294809db60f7dfd721ff7c3a3dc7d022d51 Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Fri, 18 Mar 2016 17:31:40 +0100 Subject: [PATCH 12/18] added support for unary operators --- checkstyle.json | 2 +- resources/default-config.json | 2 +- .../whitespace/OperatorWhitespaceCheck.hx | 47 +++++++++++++++---- .../checks/whitespace/WhitespaceCheck.hx | 7 +++ src/checkstyle/utils/TokenTreeCheckUtils.hx | 10 ++++ 5 files changed, 58 insertions(+), 10 deletions(-) diff --git a/checkstyle.json b/checkstyle.json index 34b27058..9e53dd95 100644 --- a/checkstyle.json +++ b/checkstyle.json @@ -338,7 +338,7 @@ { "props": { "assignOpPolicy": "around", - "unaryOpPolicy": "ignore", + "unaryOpPolicy": "none", "arithmeticOpPolicy": "around", "compareOpPolicy": "around", "bitwiseOpPolicy": "around", diff --git a/resources/default-config.json b/resources/default-config.json index 41ff43df..c8885686 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -344,7 +344,7 @@ }, { "props": { - "unaryOpPolicy": "ignore", + "unaryOpPolicy": "none", "boolOpPolicy": "around", "intervalOpPolicy": "none", "assignOpPolicy": "around", diff --git a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx index a7267368..3c578e6a 100644 --- a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx @@ -4,19 +4,20 @@ import checkstyle.Checker.LinePos; import checkstyle.token.TokenTree; import checkstyle.utils.TokenTreeCheckUtils; import checkstyle.checks.whitespace.WhitespaceCheck.WhitespacePolicy; +import checkstyle.checks.whitespace.WhitespaceCheck.WhitespaceUnaryPolicy; import haxeparser.Data; import haxe.macro.Expr; using checkstyle.utils.ArrayUtils; @name("OperatorWhitespace") -@desc("Checks that is present or absent around a operators.") +@desc("Checks that whitespace is present or absent around a operators.") class OperatorWhitespaceCheck extends Check { // =, +=, -=, *=, /=, <<=, >>=, >>>=, &=, |=, ^= public var assignOpPolicy:WhitespacePolicy; // ++, --, ! - public var unaryOpPolicy:WhitespacePolicy; + public var unaryOpPolicy:WhitespaceUnaryPolicy; // +, -, *, /, % public var arithmeticOpPolicy:WhitespacePolicy; // ==, !=, <, <=, >, >= @@ -31,7 +32,7 @@ class OperatorWhitespaceCheck extends Check { public function new() { super(TOKEN); assignOpPolicy = AROUND; - unaryOpPolicy = IGNORE; + unaryOpPolicy = NONE; arithmeticOpPolicy = AROUND; compareOpPolicy = AROUND; bitwiseOpPolicy = AROUND; @@ -45,8 +46,7 @@ class OperatorWhitespaceCheck extends Check { var root:TokenTree = checker.getTokenTree(); checkAssignOps(root); - // TODO figure out Unary - //checkUnaryOps(root); + checkUnaryOps(root); checkArithmeticOps(root); checkCompareOps(root); checkBitwiseOps(root); @@ -81,7 +81,11 @@ class OperatorWhitespaceCheck extends Check { Unop(OpIncrement), Unop(OpDecrement) ], ALL); - checkTokenList(tokens, unaryOpPolicy); + + for (token in tokens) { + if (isPosSuppressed(token.pos)) continue; + checkUnaryWhitespace(token, unaryOpPolicy); + } } function checkArithmeticOps(root:TokenTree) { @@ -154,12 +158,13 @@ class OperatorWhitespaceCheck extends Check { function checkWhitespace(tok:TokenTree, policy:WhitespacePolicy) { var linePos:LinePos = checker.getLinePos(tok.pos.min); + var tokLen:Int = TokenDefPrinter.print(tok.tok).length; if (tok.tok.match(IntInterval(_))) { linePos = checker.getLinePos(tok.pos.max - 3); + tokLen = 3; } var line:String = checker.lines[linePos.line]; var before:String = line.substr(0, linePos.ofs); - var tokLen:Int = TokenDefPrinter.print(tok.tok).length; var after:String = line.substr(linePos.ofs + tokLen); var whitespaceBefore:Bool = ~/^(.*\s|)$/.match(before); @@ -179,7 +184,33 @@ class OperatorWhitespaceCheck extends Check { default: return; } + logPos('OperatorWhitespace policy "$policy" violated by "${TokenDefPrinter.print(tok.tok)}"', tok.pos); + } + function checkUnaryWhitespace(tok:TokenTree, policy:WhitespaceUnaryPolicy) { + var linePos:LinePos = checker.getLinePos(tok.pos.min); + var tokLen:Int = TokenDefPrinter.print(tok.tok).length; + var line:String = checker.lines[linePos.line]; + var before:String = line.substr(0, linePos.ofs); + var after:String = line.substr(linePos.ofs + tokLen); + + var whitespaceBefore:Bool = ~/^(.*\s|)$/.match(before); + var whitespaceAfter:Bool = ~/^(\s.*|)$/.match(after); + + var leftSide:Bool = TokenTreeCheckUtils.isUnaryLeftSided(tok); + + switch (policy) { + case INNER: + if (leftSide && whitespaceAfter) return; + if (!leftSide && whitespaceBefore) return; + case NONE: + if (leftSide && !whitespaceAfter) return; + if (!leftSide && !whitespaceBefore) return; + case IGNORE: + return; + default: + return; + } logPos('OperatorWhitespace policy "$policy" violated by "${TokenDefPrinter.print(tok.tok)}"', tok.pos); } -} +} \ No newline at end of file diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx index d192f268..572bbceb 100644 --- a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx @@ -317,4 +317,11 @@ abstract WhitespacePolicy(String) { var AROUND = "around"; var NONE = "none"; var IGNORE = "ignore"; +} + +@:enum +abstract WhitespaceUnaryPolicy(String) { + var INNER = "inner"; + var NONE = "none"; + var IGNORE = "ignore"; } \ No newline at end of file diff --git a/src/checkstyle/utils/TokenTreeCheckUtils.hx b/src/checkstyle/utils/TokenTreeCheckUtils.hx index 6f5d082b..b7a4a9f8 100644 --- a/src/checkstyle/utils/TokenTreeCheckUtils.hx +++ b/src/checkstyle/utils/TokenTreeCheckUtils.hx @@ -56,4 +56,14 @@ class TokenTreeCheckUtils { default: false; } } + + function isUnaryLeftSided(tok:TokenTree):Bool { + var child:TokenTree = tok.getFirstChild(); + + if (child == null) return false; + return switch (child.tok) { + case Const(_): true; + default: false; + } + } } \ No newline at end of file From 5588099ddf1ac1518b02ec194d9b01a089ecd724 Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Fri, 18 Mar 2016 17:37:18 +0100 Subject: [PATCH 13/18] compile fix --- .../checks/whitespace/WhitespaceCheck.hx | 61 +------------------ src/checkstyle/utils/TokenTreeCheckUtils.hx | 2 +- test/checks/whitespace/WhitespaceCheckTest.hx | 43 ++++++------- 3 files changed, 22 insertions(+), 84 deletions(-) diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx index 572bbceb..574c791c 100644 --- a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx @@ -19,7 +19,7 @@ class WhitespaceCheck extends Check { public function new() { super(TOKEN); tokens = [ - ARROW, ASSIGN, UNARY, COMPARE, BITWISE, BOOL + ARROW, ]; mode = AROUND; contexts = [OBJECT_DECL, FUNCTION, FIELD, SWITCH, TRY_CATCH, ARRAY_ACCESS, BLOCK, CLASS, INTERFACE, TYPEDEF, ABSTRACT, ENUM]; @@ -32,56 +32,6 @@ class WhitespaceCheck extends Check { for (token in tokens) { switch (token) { - case ASSIGN: - tokenList = tokenList.concat([ - Binop(OpAssign), - Binop(OpAssignOp(OpAdd)), - Binop(OpAssignOp(OpSub)), - Binop(OpAssignOp(OpMult)), - Binop(OpAssignOp(OpDiv)), - Binop(OpAssignOp(OpMod)), - Binop(OpAssignOp(OpShl)), - Binop(OpAssignOp(OpShr)), - Binop(OpAssignOp(OpUShr)), - Binop(OpAssignOp(OpOr)), - Binop(OpAssignOp(OpAnd)), - Binop(OpAssignOp(OpXor)) - ]); - case UNARY: - tokenList = tokenList.concat([ - Unop(OpNot), - Unop(OpIncrement), - Unop(OpDecrement) - ]); - case COMPARE: - tokenList = tokenList.concat([ - Binop(OpGt), - Binop(OpLt), - Binop(OpGte), - Binop(OpLte), - Binop(OpEq), - Binop(OpNotEq) - ]); - case ARITHMETIC: - tokenList = tokenList.concat([ - Binop(OpAdd), - Binop(OpSub), - Binop(OpMult), - Binop(OpDiv), - Binop(OpMod) - ]); - case BITWISE: - tokenList = tokenList.concat([ - Binop(OpAnd), - Binop(OpOr), - Binop(OpXor), - Binop(OpShl), - Binop(OpShr), - Binop(OpUShr) - ]); - case BOOL: - tokenList.push(Binop(OpBoolAnd)); - tokenList.push(Binop(OpBoolOr)); case ARROW: tokenList.push(Arrow); case COMMA: @@ -104,8 +54,6 @@ class WhitespaceCheck extends Check { tokenList.push(DblDot); case DOT: tokenList.push(Dot); - case INTERVAL: - tokenList.push(Binop(OpInterval)); } } @@ -290,12 +238,6 @@ abstract WhitespaceContext(String) { @:enum abstract WhitespaceToken(String) { - var ASSIGN = "Assign"; - var UNARY = "Unary"; - var COMPARE = "Compare"; - var ARITHMETIC = "Arithmetic"; - var BITWISE = "Bitwise"; - var BOOL = "Bool"; var ARROW = "=>"; var COMMA = ","; var SEMICOLON = ";"; @@ -307,7 +249,6 @@ abstract WhitespaceToken(String) { var BKCLOSE = "]"; var DBLDOT = ":"; var DOT = "."; - var INTERVAL = "..."; } @:enum diff --git a/src/checkstyle/utils/TokenTreeCheckUtils.hx b/src/checkstyle/utils/TokenTreeCheckUtils.hx index b7a4a9f8..10cb72a7 100644 --- a/src/checkstyle/utils/TokenTreeCheckUtils.hx +++ b/src/checkstyle/utils/TokenTreeCheckUtils.hx @@ -57,7 +57,7 @@ class TokenTreeCheckUtils { } } - function isUnaryLeftSided(tok:TokenTree):Bool { + public static function isUnaryLeftSided(tok:TokenTree):Bool { var child:TokenTree = tok.getFirstChild(); if (child == null) return false; diff --git a/test/checks/whitespace/WhitespaceCheckTest.hx b/test/checks/whitespace/WhitespaceCheckTest.hx index c3a039d8..a5621455 100644 --- a/test/checks/whitespace/WhitespaceCheckTest.hx +++ b/test/checks/whitespace/WhitespaceCheckTest.hx @@ -25,32 +25,29 @@ class WhitespaceCheckTest extends CheckTestCase { assertNoMsg(check, OPGT); } - public function testIncorrectWhitespace() { - var check = new WhitespaceCheck(); - assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); - assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); - assertMsg(check, ISSUE_59, MSG_EQUALS); - assertMsg(check, ISSUE_63, MSG_EQUALS); - } - - public function testIncorrectWhitespaceToken() { - var check = new WhitespaceCheck(); - check.tokens = [ASSIGN]; - assertNoMsg(check, CORRECT_WHITESPACE_AROUND); - assertMsg(check, NO_WHITESPACE_GT, MSG_EQUALS); - assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); - assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); - assertMsg(check, NO_WHITESPACE_VAR_INIT, MSG_EQUALS); - - check.tokens = [COMPARE]; - assertNoMsg(check, CORRECT_WHITESPACE_AROUND); - assertNoMsg(check, NO_WHITESPACE_VAR_INIT); - assertNoMsg(check, NO_WHITESPACE_GT); - } + //public function testIncorrectWhitespace() { + // var check = new WhitespaceCheck(); + // assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); + // assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); + // assertMsg(check, ISSUE_59, MSG_EQUALS); + // assertMsg(check, ISSUE_63, MSG_EQUALS); + //} + + //public function testIncorrectWhitespaceToken() { + // var check = new WhitespaceCheck(); + // assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + // assertMsg(check, NO_WHITESPACE_GT, MSG_EQUALS); + // assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); + // assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); + // assertMsg(check, NO_WHITESPACE_VAR_INIT, MSG_EQUALS); + + // assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + // assertNoMsg(check, NO_WHITESPACE_VAR_INIT); + // assertNoMsg(check, NO_WHITESPACE_GT); + //} public function testStarImport() { var check = new WhitespaceCheck(); - check.tokens = [ARITHMETIC]; assertNoMsg(check, ISSUE_70); assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); From 61ec716d14649b8af2c1da3d737964139f7fa33f Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Fri, 18 Mar 2016 17:51:50 +0100 Subject: [PATCH 14/18] added unittest for OperatorWhitespaceCheck --- resources/default-config.json | 7 +- .../whitespace/OperatorWhitespaceCheck.hx | 2 + .../whitespace/OperatorWhitespaceCheckTest.hx | 283 ++++++++++++++++++ 3 files changed, 286 insertions(+), 6 deletions(-) create mode 100644 test/checks/whitespace/OperatorWhitespaceCheckTest.hx diff --git a/resources/default-config.json b/resources/default-config.json index c8885686..aee4356a 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -564,12 +564,7 @@ "props": { "mode": "around", "tokens": [ - "=>", - "Assign", - "Unary", - "Compare", - "Bitwise", - "Bool" + "=>" ], "contexts": [ "Object", diff --git a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx index 3c578e6a..10b26784 100644 --- a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx @@ -151,7 +151,9 @@ class OperatorWhitespaceCheck extends Check { function checkTokenList(tokens:Array, policy:WhitespacePolicy) { for (token in tokens) { if (isPosSuppressed(token.pos)) continue; + if (TokenTreeCheckUtils.isImportMult(token)) continue; if (TokenTreeCheckUtils.isTypeParameter(token)) continue; + if (TokenTreeCheckUtils.filterOpSub(token)) continue; checkWhitespace(token, policy); } } diff --git a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx new file mode 100644 index 00000000..5e5b9796 --- /dev/null +++ b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx @@ -0,0 +1,283 @@ +package checks.whitespace; + +import checkstyle.checks.whitespace.OperatorWhitespaceCheck; + +class OperatorWhitespaceCheckTest extends CheckTestCase { + + static inline var MSG_EQUALS:String = 'OperatorWhitespace policy "around" violated by "="'; + static inline var MSG_UNARY_NONE:String = 'OperatorWhitespace policy "none" violated by "++"'; + static inline var MSG_UNARY_INNER:String = 'OperatorWhitespace policy "inner" violated by "++"'; + + public function testCorrectOperatorWhitespace() { + var check = new OperatorWhitespaceCheck(); + assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + assertNoMsg(check, ISSUE_70); + assertNoMsg(check, ISSUE_71); + assertNoMsg(check, ISSUE_72); + assertNoMsg(check, ISSUE_77); + assertNoMsg(check, ISSUE_80); + assertNoMsg(check, ISSUE_81); + assertNoMsg(check, ISSUE_98); + assertNoMsg(check, MINUS_CONSTANT); + assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); + assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); + assertNoMsg(check, CONDITIONAL_ELSEIF_STAR_IMPORT); + assertNoMsg(check, NEGATIVE_VARS); + assertNoMsg(check, NEGATIVE_NUMS); + assertNoMsg(check, OPGT); + } + + public function testIncorrectOperatorWhitespace() { + var check = new OperatorWhitespaceCheck(); + assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); + assertMsg(check, ISSUE_59, MSG_EQUALS); + assertMsg(check, ISSUE_63, MSG_EQUALS); + } + + public function testIncorrectOperatorWhitespaceToken() { + var check = new OperatorWhitespaceCheck(); + assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + assertMsg(check, NO_WHITESPACE_GT, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); + assertMsg(check, NO_WHITESPACE_VAR_INIT, MSG_EQUALS); + + assertNoMsg(check, CORRECT_WHITESPACE_AROUND); + } + + public function testStarImport() { + var check = new OperatorWhitespaceCheck(); + assertNoMsg(check, ISSUE_70); + assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); + assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); + assertNoMsg(check, CONDITIONAL_ELSEIF_STAR_IMPORT); + } + + public function testUnary() { + var check = new OperatorWhitespaceCheck(); + + assertNoMsg(check, UNARY_NO_WHITESPACE); + assertMsg(check, UNARY_INNER_WHITESPACE, MSG_UNARY_NONE); + + check.unaryOpPolicy = INNER; + assertMsg(check, UNARY_NO_WHITESPACE, MSG_UNARY_INNER); + assertNoMsg(check, UNARY_INNER_WHITESPACE); + } +} + +@:enum +abstract OperatorWhitespaceCheckTests(String) to String { + var CORRECT_WHITESPACE_AROUND = " + import haxe.macro.*; + + class Test { + function test(param1:String, param2:String) { + var x = { x: 100, y: 100, + z: 20 * 10 + }; + var y:Array = []; + } + } + + typedef Test = { + x:Int, + y:Int, z:Int + } + + enum Test { + Monday; + Tuesday; + Wednesday; + Thursday; + Friday; Weekend(day:String); + }"; + + var NO_WHITESPACE_OBJECT_DECL = " + class Test { + function test(param1:String, param2:String) { + var x={ x: 100, y: 100,z: 20 }; + } + }"; + + var NO_WHITESPACE_TYPEDEF = " + typedef Test ={ + x:Int, + y:Int,z:Int + }"; + + var NO_WHITESPACE_VAR_INIT = " + class Test { + function test(param1:String, param2:String) { + var test:Array=[]; + } + }"; + + var NO_WHITESPACE_GT = " + class Test { + function test(param1:String, param2:String) { + var test:Array= []; + } + }"; + + var ISSUE_58 = " + class Test { + public function new() { + var x:Int, y:Int; + } + }"; + + var ISSUE_59 = " + typedef Test=Int + "; + + var ISSUE_63 = " + typedef Test =#if true Int #else String #end + "; + + var ISSUE_70 = " + import haxe.macro.*; + "; + + var ISSUE_71 = " + class Test { + function foo() { + trace((null : Array)); + } + }"; + + var ISSUE_72 = " + abstract Test(Array) {} + "; + + var ISSUE_77 = " + // comment + class Test // comment + { // comment + function foo() // comment + { // comment + switch ('Test') // comment + { // comment + } // comment + } // comment + } // comment + "; + + var ISSUE_80 = " + interface Test implements Dynamic {} + "; + + var ISSUE_81 = " + class Test { + function foo() { + do a++ while (true); + do ++a while (true); + } + }"; + + var ISSUE_98 = " + class Test { + // °öäüßÖÄÜ@łĸŋđđðſðæµ”“„¢«»Ø→↓←Ŧ¶€Ł}][{¬½¼³² + var test:Int = 0; + }"; + + var MINUS_CONSTANT = " + class Test { + function test() { + if (re.match(line) && line.indexOf('//') == -1) { + log('Tab after non-space character, Use space for aligning', i + 1, line.length, null, Reflect.field(SeverityLevel, severity)); + return -1; + } + a = 1 - -2; + b = 1.2 - -2.1; + return -1; + } + }"; + + var CONDITIONAL_STAR_IMPORT_ISSUE_160 = " + #if macro + import haxe.macro.*; + #end"; + + var CONDITIONAL_ELSEIF_STAR_IMPORT = " + #if macro + import haxe.macro.Type; + #elseif neko + import haxe.macro.*; + #elseif neko + import haxe.macro.*; + #else + #if linux + import haxe.macro.Type; + #else + import haxe.macro.*; + #end + #end + import haxe.macro.Type;"; + + var CONDITIONAL_ELSE_STAR_IMPORT = " + #if macro + import haxe.macro.Type; + #else + import haxe.macro.*; + #end + import haxe.macro.Type;"; + + var NEGATIVE_VARS = " + class Test { + function test() { + var rest = if (neg) { -noFractions; } + else { -noFractions; } + var rest = if (neg) -noFractions; + else -noFractions; + var x = neg ? -frag : -frag; + calc ([-width, -node.right, root], -node.left, {x : -x, y: -y}); + (-a); + (1 * -a); + do -a * 2 while(true); + for (a in [-1, -2]) -a + 2; + return -a; + } + }"; + + var NEGATIVE_NUMS = " + class Test { + function test() { + var rest = if (neg) { -8; } + else { -9; } + var rest = if (neg) -10; + else -11; + var x = neg ? -12 : -13; + calc ([-14, -node.right, root], -node.left, {x : -xi15x, y: -16}); + (-16); + (1 * -17); + do -18 * 2 while(true); + for (a in [-1, -2]) -18 + 2; + } + }"; + + var OPGT = " + class Test { + function test() { + if (a > b) return a >= b; + if (a >> b > c) return a >>= b; + if (a >>> b > c) return a >>>= b; + } + }"; + + var UNARY_NO_WHITESPACE = " + class Test { + function test() { + if (!test) return a++; + ++a; + } + }"; + + var UNARY_INNER_WHITESPACE = " + class Test { + function test() { + if (! test) return a ++; + ++ a; + } + }"; +} \ No newline at end of file From b6519877ccb0338fe9b4682aebefc77bb76f3bca Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Fri, 18 Mar 2016 18:42:46 +0100 Subject: [PATCH 15/18] added unittests for OperatorWhitespaceCheck --- .../whitespace/OperatorWhitespaceCheckTest.hx | 66 ++++++++++++++++--- 1 file changed, 58 insertions(+), 8 deletions(-) diff --git a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx index 5e5b9796..ec813466 100644 --- a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx +++ b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx @@ -5,8 +5,12 @@ import checkstyle.checks.whitespace.OperatorWhitespaceCheck; class OperatorWhitespaceCheckTest extends CheckTestCase { static inline var MSG_EQUALS:String = 'OperatorWhitespace policy "around" violated by "="'; + static inline var MSG_EQUALS_BEFORE:String = 'OperatorWhitespace policy "before" violated by "="'; + static inline var MSG_EQUALS_AFTER:String = 'OperatorWhitespace policy "after" violated by "="'; static inline var MSG_UNARY_NONE:String = 'OperatorWhitespace policy "none" violated by "++"'; static inline var MSG_UNARY_INNER:String = 'OperatorWhitespace policy "inner" violated by "++"'; + static inline var MSG_INTERVAL_NONE:String = 'OperatorWhitespace policy "none" violated by "..."'; + static inline var MSG_INTERVAL_AROUND:String = 'OperatorWhitespace policy "around" violated by "..."'; public function testCorrectOperatorWhitespace() { var check = new OperatorWhitespaceCheck(); @@ -27,17 +31,10 @@ class OperatorWhitespaceCheckTest extends CheckTestCase Date: Fri, 18 Mar 2016 20:57:54 +0100 Subject: [PATCH 16/18] added handling of !( + ignore unittests --- src/checkstyle/utils/TokenTreeCheckUtils.hx | 1 + .../whitespace/OperatorWhitespaceCheckTest.hx | 33 +++++++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/src/checkstyle/utils/TokenTreeCheckUtils.hx b/src/checkstyle/utils/TokenTreeCheckUtils.hx index 10cb72a7..622b581c 100644 --- a/src/checkstyle/utils/TokenTreeCheckUtils.hx +++ b/src/checkstyle/utils/TokenTreeCheckUtils.hx @@ -63,6 +63,7 @@ class TokenTreeCheckUtils { if (child == null) return false; return switch (child.tok) { case Const(_): true; + case POpen: true; default: false; } } diff --git a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx index ec813466..75239eeb 100644 --- a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx +++ b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx @@ -98,6 +98,39 @@ class OperatorWhitespaceCheckTest extends CheckTestCase Date: Fri, 18 Mar 2016 22:37:19 +0100 Subject: [PATCH 17/18] fixed checkstyle messages --- src/checkstyle/Checker.hx | 2 +- src/checkstyle/ChecksInfo.hx | 2 +- src/checkstyle/checks/Check.hx | 2 +- src/checkstyle/checks/coding/DefaultComesLastCheck.hx | 2 +- src/checkstyle/checks/size/LineLengthCheck.hx | 2 +- src/checkstyle/checks/whitespace/EmptyLinesCheck.hx | 2 +- src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx | 2 +- src/checkstyle/checks/whitespace/TabForAligningCheck.hx | 2 +- src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx | 2 +- test/TestMain.hx | 2 +- test/checks/whitespace/OperatorWhitespaceCheckTest.hx | 2 ++ 11 files changed, 12 insertions(+), 10 deletions(-) diff --git a/src/checkstyle/Checker.hx b/src/checkstyle/Checker.hx index d131ce0f..1b8ca060 100644 --- a/src/checkstyle/Checker.hx +++ b/src/checkstyle/Checker.hx @@ -85,7 +85,7 @@ class Checker { function findLineSeparator() { var code = file.content; - for (i in 0 ... code.length) { + for (i in 0...code.length) { var char = code.charAt(i); if (char == "\r" || char == "\n") { lineSeparator = char; diff --git a/src/checkstyle/ChecksInfo.hx b/src/checkstyle/ChecksInfo.hx index 6344380d..e8144fdb 100644 --- a/src/checkstyle/ChecksInfo.hx +++ b/src/checkstyle/ChecksInfo.hx @@ -15,7 +15,7 @@ class ChecksInfo { for (cl in checksClasses) { if (ignoreClass(cl)) continue; var names:Array = getCheckNameFromClass(cl); - for (i in 0 ... names.length) { + for (i in 0...names.length) { var desc = getCheckDescription(cl); checkInfos[names[i]] = { name: names[i], diff --git a/src/checkstyle/checks/Check.hx b/src/checkstyle/checks/Check.hx index 93ad7309..cc27ff99 100644 --- a/src/checkstyle/checks/Check.hx +++ b/src/checkstyle/checks/Check.hx @@ -113,7 +113,7 @@ class Check { function isLineSuppressed(i:Int):Bool { var pos:Int = 0; - for (j in 0 ... i + 1) pos += checker.lines[j].length; + for (j in 0...i + 1) pos += checker.lines[j].length; return isCharPosSuppressed(pos); } diff --git a/src/checkstyle/checks/coding/DefaultComesLastCheck.hx b/src/checkstyle/checks/coding/DefaultComesLastCheck.hx index 358261e8..aeee79eb 100644 --- a/src/checkstyle/checks/coding/DefaultComesLastCheck.hx +++ b/src/checkstyle/checks/coding/DefaultComesLastCheck.hx @@ -21,7 +21,7 @@ class DefaultComesLastCheck extends Check { if (tokens[tokens.length - 1].is(Kwd(KwdDefault))) continue; var defaultExists = false; - for (i in 0 ... tokens.length) { + for (i in 0...tokens.length) { if (tokens[i].is(Kwd(KwdDefault)) && i < tokens.length - 1) { logPos("Default should be last label in the switch", token.pos); continue; diff --git a/src/checkstyle/checks/size/LineLengthCheck.hx b/src/checkstyle/checks/size/LineLengthCheck.hx index 12d9bb51..8b4d57a8 100644 --- a/src/checkstyle/checks/size/LineLengthCheck.hx +++ b/src/checkstyle/checks/size/LineLengthCheck.hx @@ -19,7 +19,7 @@ class LineLengthCheck extends Check { override function actualRun() { var ignoreRE = new EReg(ignorePattern, ""); - for (i in 0 ... checker.lines.length) { + for (i in 0...checker.lines.length) { var line = checker.lines[i]; if (line.length > max) { if (ignoreRE.match(line) || isLineSuppressed(i)) continue; diff --git a/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx b/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx index 03ab075b..36b558ce 100644 --- a/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx +++ b/src/checkstyle/checks/whitespace/EmptyLinesCheck.hx @@ -35,7 +35,7 @@ class EmptyLinesCheck extends LineCheckBase { var start = 0; var end = 0; - for (i in 0 ... checker.lines.length) { + for (i in 0...checker.lines.length) { var line = checker.lines[i]; if (isMultineString(line)) continue; if (~/^\s*$/.match(line)) { diff --git a/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx b/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx index ded25cb4..f77a4ed8 100644 --- a/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx +++ b/src/checkstyle/checks/whitespace/IndentationCharacterCheck.hx @@ -16,7 +16,7 @@ class IndentationCharacterCheck extends LineCheckBase { override function actualRun() { var ignoreRE = new EReg(ignorePattern, ""); var re = (character == TAB) ? ~/^\t*(\S.*| \*.*)?$/ : ~/^ *(\S.*)?$/; - for (i in 0 ... checker.lines.length) { + for (i in 0...checker.lines.length) { var line = checker.lines[i]; if (ignoreRE.match(line) || isLineSuppressed(i)) continue; if (isMultineString(line)) continue; diff --git a/src/checkstyle/checks/whitespace/TabForAligningCheck.hx b/src/checkstyle/checks/whitespace/TabForAligningCheck.hx index 267482ed..55a14552 100644 --- a/src/checkstyle/checks/whitespace/TabForAligningCheck.hx +++ b/src/checkstyle/checks/whitespace/TabForAligningCheck.hx @@ -17,7 +17,7 @@ class TabForAligningCheck extends LineCheckBase { override function actualRun() { var ignoreRE = new EReg(ignorePattern, ""); var re = ~/^\s*\S[^\t]*\t/; - for (i in 0 ... checker.lines.length) { + for (i in 0...checker.lines.length) { var line = checker.lines[i]; if (ignoreRE.match(line)) continue; if (isMultineString(line)) continue; diff --git a/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx b/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx index eb6660e6..3de3682c 100644 --- a/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/TrailingWhitespaceCheck.hx @@ -6,7 +6,7 @@ class TrailingWhitespaceCheck extends LineCheckBase { override function actualRun() { var re = ~/\s+$/; - for (i in 0 ... checker.lines.length) { + for (i in 0...checker.lines.length) { var line = checker.lines[i]; if (isMultineString(line)) continue; if (re.match(line)) log("Trailing whitespace", i + 1, line.length); diff --git a/test/TestMain.hx b/test/TestMain.hx index 320e5ccc..ee8b13d3 100644 --- a/test/TestMain.hx +++ b/test/TestMain.hx @@ -38,7 +38,7 @@ class TestMain { for (cls in classes) { var coverageData = [null]; var results:CoverageResult = cls.getResults(); - for (i in 1 ... results.l) coverageData[i] = 1; + for (i in 1...results.l) coverageData[i] = 1; var c = cls.name.replace(".", "/") + ".hx"; var missingStatements:Array = cls.getMissingStatements(); diff --git a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx index 75239eeb..a46787d7 100644 --- a/test/checks/whitespace/OperatorWhitespaceCheckTest.hx +++ b/test/checks/whitespace/OperatorWhitespaceCheckTest.hx @@ -337,6 +337,7 @@ abstract OperatorWhitespaceCheckTests(String) to String { function test() { if (!test) return a++; ++a; + return !(a++); } }"; @@ -345,6 +346,7 @@ abstract OperatorWhitespaceCheckTests(String) to String { function test() { if (! test) return a ++; ++ a; + return ! (a ++); } }"; From 92e87014d948f937822dfb6543fa480ae2388caa Mon Sep 17 00:00:00 2001 From: AlexHaxe Date: Sat, 19 Mar 2016 01:43:58 +0100 Subject: [PATCH 18/18] removed WhitespaceCheck --- resources/default-config.json | 24 -- .../whitespace/OperatorWhitespaceCheck.hx | 18 +- .../checks/whitespace/WhitespaceCheck.hx | 268 ------------------ test/checks/whitespace/WhitespaceCheckTest.hx | 256 ----------------- 4 files changed, 16 insertions(+), 550 deletions(-) delete mode 100644 src/checkstyle/checks/whitespace/WhitespaceCheck.hx delete mode 100644 test/checks/whitespace/WhitespaceCheckTest.hx diff --git a/resources/default-config.json b/resources/default-config.json index aee4356a..8ff4136e 100644 --- a/resources/default-config.json +++ b/resources/default-config.json @@ -560,30 +560,6 @@ }, "type": "VariableInitialisation" }, - { - "props": { - "mode": "around", - "tokens": [ - "=>" - ], - "contexts": [ - "Object", - "Function", - "Field", - "Switch", - "Switch", - "Array", - "Block", - "Class", - "Interface", - "Typedef", - "Abstract", - "Enum" - ], - "severity": "IGNORE" - }, - "type": "Whitespace" - }, { "props": { "tokens": [ diff --git a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx index 10b26784..770ecc51 100644 --- a/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx +++ b/src/checkstyle/checks/whitespace/OperatorWhitespaceCheck.hx @@ -3,8 +3,6 @@ package checkstyle.checks.whitespace; import checkstyle.Checker.LinePos; import checkstyle.token.TokenTree; import checkstyle.utils.TokenTreeCheckUtils; -import checkstyle.checks.whitespace.WhitespaceCheck.WhitespacePolicy; -import checkstyle.checks.whitespace.WhitespaceCheck.WhitespaceUnaryPolicy; import haxeparser.Data; import haxe.macro.Expr; @@ -215,4 +213,20 @@ class OperatorWhitespaceCheck extends Check { } logPos('OperatorWhitespace policy "$policy" violated by "${TokenDefPrinter.print(tok.tok)}"', tok.pos); } +} + +@:enum +abstract WhitespacePolicy(String) { + var BEFORE = "before"; + var AFTER = "after"; + var AROUND = "around"; + var NONE = "none"; + var IGNORE = "ignore"; +} + +@:enum +abstract WhitespaceUnaryPolicy(String) { + var INNER = "inner"; + var NONE = "none"; + var IGNORE = "ignore"; } \ No newline at end of file diff --git a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx b/src/checkstyle/checks/whitespace/WhitespaceCheck.hx deleted file mode 100644 index 574c791c..00000000 --- a/src/checkstyle/checks/whitespace/WhitespaceCheck.hx +++ /dev/null @@ -1,268 +0,0 @@ -package checkstyle.checks.whitespace; - -import checkstyle.Checker.LinePos; -import checkstyle.token.TokenTree; -import checkstyle.utils.TokenTreeCheckUtils; -import haxeparser.Data; -import haxe.macro.Expr; - -using checkstyle.utils.ArrayUtils; - -@name("Whitespace") -@desc("Checks that is present or absent around a token.") -class WhitespaceCheck extends Check { - - public var mode:WhitespaceMode; - public var tokens:Array; - public var contexts:Array; - - public function new() { - super(TOKEN); - tokens = [ - ARROW, - ]; - mode = AROUND; - contexts = [OBJECT_DECL, FUNCTION, FIELD, SWITCH, TRY_CATCH, ARRAY_ACCESS, BLOCK, CLASS, INTERFACE, TYPEDEF, ABSTRACT, ENUM]; - - categories = [Category.STYLE, Category.CLARITY]; - } - - override function actualRun() { - var tokenList:Array = []; - - for (token in tokens) { - switch (token) { - case ARROW: - tokenList.push(Arrow); - case COMMA: - tokenList.push(Comma); - case SEMICOLON: - tokenList.push(Semicolon); - case POPEN: - tokenList.push(POpen); - case PCLOSE: - tokenList.push(PClose); - case BROPEN: - tokenList.push(BrOpen); - case BRCLOSE: - tokenList.push(BrClose); - case BKOPEN: - tokenList.push(BkOpen); - case BKCLOSE: - tokenList.push(BkClose); - case DBLDOT: - tokenList.push(DblDot); - case DOT: - tokenList.push(Dot); - } - } - - if (tokenList.length <= 0) return; - checkTokens(tokenList); - } - - function checkTokens(tokenList:Array) { - var root:TokenTree = checker.getTokenTree(); - var allTokens:Array = root.filter(tokenList, ALL); - - for (tok in allTokens) { - if (isPosSuppressed(tok.pos)) continue; - if (!checkContext(tok)) continue; - - checkWhitespace(tok); - } - } - - function checkWhitespace(tok:TokenTree) { - var linePos:LinePos = checker.getLinePos(tok.pos.min); - var line:String = checker.lines[linePos.line]; - var before:String = line.substr(0, linePos.ofs); - var tokLen:Int = TokenDefPrinter.print(tok.tok).length; - var after:String = line.substr(linePos.ofs + tokLen); - - var whitespaceBefore:Bool = ~/^(.*\s|)$/.match(before); - var whitespaceAfter:Bool = ~/^(\s.*|)$/.match(after); - - switch (mode) { - case BEFORE: - if (whitespaceBefore && !whitespaceAfter) return; - case AFTER: - if (!whitespaceBefore && whitespaceAfter) return; - case NONE: - if (!whitespaceBefore && !whitespaceAfter) return; - case AROUND: - if (whitespaceBefore && whitespaceAfter) return; - } - - logPos('Whitespace mode "$mode" violated by "${TokenDefPrinter.print(tok.tok)}"', tok.pos); - } - - function checkContext(token:TokenTree):Bool { - // TODO also handle package and using - if (TokenTreeCheckUtils.isImportMult(token)) return false; - if (TokenTreeCheckUtils.filterOpSub(token)) return false; - - var currentContext:WhitespaceContext = determineContext(token); - if (currentContext == null || !hasContext(currentContext)) return false; - - //if (TokenTreeCheckUtils.isTypeParameter(token)) { - // return hasContext(TYPE_PARAMETER); - //} - //if (!hasContext(FUNCTION)) { - // if (isFunctionContext(token)) return true; - //} - switch (token.tok) { - case Dot: - case DblDot: - default: - } - // TODO check contexts - - return true; - } - - function isFunctionContext(tok:TokenTree):Bool { - switch (tok.tok) { - case POpen, PClose, DblDot, Dot, Comma, BrOpen, BrClose: - case Binop(OpGt), Binop(OpLt), Binop(OpAssign): - default: return false; - } - var parent:TokenTree = tok.parent; - while (parent.tok != null) { - switch (parent.tok) { - case Kwd(KwdFunction): return true; - case Kwd(_): return false; - default: - } - parent = parent.parent; - } - return false; - } - - function determineContext(token:TokenTree):WhitespaceContext { - while (token.tok != null) { - switch (token.tok) { - case At: return META; - case Dollar(_): return REIFICATION; - case Kwd(KwdClass): return CLASS; - case Kwd(KwdInterface): return INTERFACE; - case Kwd(KwdEnum): return ENUM; - case Kwd(KwdAbstract): return ABSTRACT; - case Kwd(KwdTypedef): return TYPEDEF; - case Kwd(KwdCase), Kwd(KwdDefault), Kwd(KwdSwitch): return SWITCH; - case Kwd(KwdCatch): return TRY_CATCH; - - case Kwd(KwdIf), Kwd(KwdElse): return SINGLELINE; - case Kwd(KwdDo): return SINGLELINE; - case Kwd(KwdFor): return SINGLELINE; - case Kwd(KwdWhile): return SINGLELINE; - case Kwd(KwdFunction): return SINGLELINE; - case BkOpen: return ARRAY_ACCESS; - case BrOpen: return contextOfBrOpen(token.parent); - case POpen: return contextOfPOpen(token.parent); - case Binop(OpLt): - if (TokenTreeCheckUtils.isTypeParameter(token)) return TYPE_PARAMETER; - default: - } - token = token.parent; - } - - return null; - } - - function contextOfBrOpen(token:TokenTree):WhitespaceContext { - while (token.tok != null) { - switch (token.tok) { - case Kwd(_): return BLOCK; - case POpen: return OBJECT_DECL; - case Comma: return OBJECT_DECL; - case BrOpen: return contextOfBrOpen(token.parent); - case Binop(OpAssign), Binop(OpAssignOp(_)): return OBJECT_DECL; - default: - } - token = token.parent; - } - return null; - } - - function contextOfPOpen(token:TokenTree):WhitespaceContext { - while (token.tok != null) { - switch (token.tok) { - case Kwd(KwdFunction): return FUNCTION; - case POpen: return contextOfPOpen(token); - case Binop(OpAssign), Binop(OpAssignOp(_)): return COND; - case Kwd(KwdVar): return PROPERTY; - case Kwd(KwdIf), Kwd(KwdFor), Kwd(KwdWhile), Kwd(KwdSwitch), Kwd(KwdCase): return COND; - default: - } - token = token.parent; - } - return null; - } - - function hasContext(context:WhitespaceContext):Bool { - return contexts.contains(context); - } -} - -@:enum -abstract WhitespaceMode(String) { - var BEFORE = "before"; - var AFTER = "after"; - var AROUND = "around"; - var NONE = "none"; -} - -@:enum -abstract WhitespaceContext(String) { - var OBJECT_DECL = "Object"; - var CLASS = "Class"; - var INTERFACE = "Interface"; - var TYPEDEF = "Typedef"; - var ABSTRACT = "Abstract"; - var ENUM = "Enum"; - var FUNCTION = "Function"; - var FIELD = "Field"; - var PROPERTY = "Property"; - var BLOCK = "Block"; - var IF = "If"; - var COND = "Condition"; - var SWITCH = "Switch"; - var TRY_CATCH = "Switch"; - var ARRAY_ACCESS = "Array"; - var REIFICATION = "Reification"; - var TYPE_PARAMETER = "TypeParameter"; - var META = "Meta"; - var SINGLELINE = "Singleline"; -} - -@:enum -abstract WhitespaceToken(String) { - var ARROW = "=>"; - var COMMA = ","; - var SEMICOLON = ";"; - var POPEN = "("; - var PCLOSE = ")"; - var BROPEN = "{"; - var BRCLOSE = "}"; - var BKOPEN = "["; - var BKCLOSE = "]"; - var DBLDOT = ":"; - var DOT = "."; -} - -@:enum -abstract WhitespacePolicy(String) { - var BEFORE = "before"; - var AFTER = "after"; - var AROUND = "around"; - var NONE = "none"; - var IGNORE = "ignore"; -} - -@:enum -abstract WhitespaceUnaryPolicy(String) { - var INNER = "inner"; - var NONE = "none"; - var IGNORE = "ignore"; -} \ No newline at end of file diff --git a/test/checks/whitespace/WhitespaceCheckTest.hx b/test/checks/whitespace/WhitespaceCheckTest.hx deleted file mode 100644 index a5621455..00000000 --- a/test/checks/whitespace/WhitespaceCheckTest.hx +++ /dev/null @@ -1,256 +0,0 @@ -package checks.whitespace; - -import checkstyle.checks.whitespace.WhitespaceCheck; - -class WhitespaceCheckTest extends CheckTestCase { - - static inline var MSG_EQUALS:String = 'Whitespace mode "around" violated by "="'; - - public function testCorrectWhitespace() { - var check = new WhitespaceCheck(); - assertNoMsg(check, CORRECT_WHITESPACE_AROUND); - assertNoMsg(check, ISSUE_70); - assertNoMsg(check, ISSUE_71); - assertNoMsg(check, ISSUE_72); - assertNoMsg(check, ISSUE_77); - assertNoMsg(check, ISSUE_80); - assertNoMsg(check, ISSUE_81); - assertNoMsg(check, ISSUE_98); - assertNoMsg(check, MINUS_CONSTANT); - assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); - assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); - assertNoMsg(check, CONDITIONAL_ELSEIF_STAR_IMPORT); - assertNoMsg(check, NEGATIVE_VARS); - assertNoMsg(check, NEGATIVE_NUMS); - assertNoMsg(check, OPGT); - } - - //public function testIncorrectWhitespace() { - // var check = new WhitespaceCheck(); - // assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); - // assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); - // assertMsg(check, ISSUE_59, MSG_EQUALS); - // assertMsg(check, ISSUE_63, MSG_EQUALS); - //} - - //public function testIncorrectWhitespaceToken() { - // var check = new WhitespaceCheck(); - // assertNoMsg(check, CORRECT_WHITESPACE_AROUND); - // assertMsg(check, NO_WHITESPACE_GT, MSG_EQUALS); - // assertMsg(check, NO_WHITESPACE_OBJECT_DECL, MSG_EQUALS); - // assertMsg(check, NO_WHITESPACE_TYPEDEF, MSG_EQUALS); - // assertMsg(check, NO_WHITESPACE_VAR_INIT, MSG_EQUALS); - - // assertNoMsg(check, CORRECT_WHITESPACE_AROUND); - // assertNoMsg(check, NO_WHITESPACE_VAR_INIT); - // assertNoMsg(check, NO_WHITESPACE_GT); - //} - - public function testStarImport() { - var check = new WhitespaceCheck(); - assertNoMsg(check, ISSUE_70); - assertNoMsg(check, CONDITIONAL_STAR_IMPORT_ISSUE_160); - assertNoMsg(check, CONDITIONAL_ELSE_STAR_IMPORT); - assertNoMsg(check, CONDITIONAL_ELSEIF_STAR_IMPORT); - } -} - -@:enum -abstract WhitespaceCheckTests(String) to String { - var CORRECT_WHITESPACE_AROUND = " - import haxe.macro.*; - - class Test { - function test(param1:String, param2:String) { - var x = { x: 100, y: 100, - z: 20 * 10 - }; - var y:Array = []; - } - } - - typedef Test = { - x:Int, - y:Int, z:Int - } - - enum Test { - Monday; - Tuesday; - Wednesday; - Thursday; - Friday; Weekend(day:String); - }"; - - var NO_WHITESPACE_OBJECT_DECL = " - class Test { - function test(param1:String, param2:String) { - var x={ x: 100, y: 100,z: 20 }; - } - }"; - - var NO_WHITESPACE_TYPEDEF = " - typedef Test ={ - x:Int, - y:Int,z:Int - }"; - - var NO_WHITESPACE_VAR_INIT = " - class Test { - function test(param1:String, param2:String) { - var test:Array=[]; - } - }"; - - var NO_WHITESPACE_GT = " - class Test { - function test(param1:String, param2:String) { - var test:Array= []; - } - }"; - - var ISSUE_58 = " - class Test { - public function new() { - var x:Int, y:Int; - } - }"; - - var ISSUE_59 = " - typedef Test=Int - "; - - var ISSUE_63 = " - typedef Test =#if true Int #else String #end - "; - - var ISSUE_70 = " - import haxe.macro.*; - "; - - var ISSUE_71 = " - class Test { - function foo() { - trace((null : Array)); - } - }"; - - var ISSUE_72 = " - abstract Test(Array) {} - "; - - var ISSUE_77 = " - // comment - class Test // comment - { // comment - function foo() // comment - { // comment - switch ('Test') // comment - { // comment - } // comment - } // comment - } // comment - "; - - var ISSUE_80 = " - interface Test implements Dynamic {} - "; - - var ISSUE_81 = " - class Test { - function foo() { - do a++ while (true); - do ++a while (true); - } - }"; - - var ISSUE_98 = " - class Test { - // °öäüßÖÄÜ@łĸŋđđðſðæµ”“„¢«»Ø→↓←Ŧ¶€Ł}][{¬½¼³² - var test:Int = 0; - }"; - - var MINUS_CONSTANT = " - class Test { - function test() { - if (re.match(line) && line.indexOf('//') == -1) { - log('Tab after non-space character, Use space for aligning', i + 1, line.length, null, Reflect.field(SeverityLevel, severity)); - return -1; - } - a = 1 - -2; - b = 1.2 - -2.1; - return -1; - } - }"; - - var CONDITIONAL_STAR_IMPORT_ISSUE_160 = " - #if macro - import haxe.macro.*; - #end"; - - var CONDITIONAL_ELSEIF_STAR_IMPORT = " - #if macro - import haxe.macro.Type; - #elseif neko - import haxe.macro.*; - #elseif neko - import haxe.macro.*; - #else - #if linux - import haxe.macro.Type; - #else - import haxe.macro.*; - #end - #end - import haxe.macro.Type;"; - - var CONDITIONAL_ELSE_STAR_IMPORT = " - #if macro - import haxe.macro.Type; - #else - import haxe.macro.*; - #end - import haxe.macro.Type;"; - - var NEGATIVE_VARS = " - class Test { - function test() { - var rest = if (neg) { -noFractions; } - else { -noFractions; } - var rest = if (neg) -noFractions; - else -noFractions; - var x = neg ? -frag : -frag; - calc ([-width, -node.right, root], -node.left, {x : -x, y: -y}); - (-a); - (1 * -a); - do -a * 2 while(true); - for (a in [-1, -2]) -a + 2; - return -a; - } - }"; - - var NEGATIVE_NUMS = " - class Test { - function test() { - var rest = if (neg) { -8; } - else { -9; } - var rest = if (neg) -10; - else -11; - var x = neg ? -12 : -13; - calc ([-14, -node.right, root], -node.left, {x : -xi15x, y: -16}); - (-16); - (1 * -17); - do -18 * 2 while(true); - for (a in [-1, -2]) -18 + 2; - } - }"; - - var OPGT = " - class Test { - function test() { - if (a > b) return a >= b; - if (a >> b > c) return a >>= b; - if (a >>> b > c) return a >>>= b; - } - }"; -} \ No newline at end of file