Python doesn't need braces

sambsnyd · sambsnyd · commit abb033844c2c · 2024-09-09T11:27:16.000-07:00
diff --git a/src/main/java/org/openrewrite/staticanalysis/NeedBraces.java b/src/main/java/org/openrewrite/staticanalysis/NeedBraces.java
@@ -60,6 +60,8 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
     }
 
     private static class NeedBracesVisitor extends JavaIsoVisitor<ExecutionContext> {
+
+        @SuppressWarnings("NotNullFieldNotInitialized")
         NeedBracesStyle needBracesStyle;
 
         /**
@@ -92,10 +94,16 @@ private <T extends Statement> J.Block buildBlock(Statement owner, T element) {
         }
 
         @Override
-        public J visit(@Nullable Tree tree, ExecutionContext ctx) {
-            if (tree instanceof JavaSourceFile) {
+        public @Nullable J visit(@Nullable Tree tree, ExecutionContext ctx) {
+            if (tree instanceof SourceFile) {
                 SourceFile cu = (SourceFile) requireNonNull(tree);
-                needBracesStyle = cu.getStyle(NeedBracesStyle.class) == null ? Checkstyle.needBracesStyle() : cu.getStyle(NeedBracesStyle.class);
+                // Python don't need none of your curly braces
+                if (cu.getSourcePath().toString().endsWith(".py")) {
+                    return (J) tree;
+                }
+                needBracesStyle = cu.getStyle(NeedBracesStyle.class) == null ?
+                        Checkstyle.needBracesStyle() :
+                        cu.getStyle(NeedBracesStyle.class, new NeedBracesStyle(false, false));
             }
             return super.visit(tree, ctx);
         }
@@ -201,6 +209,4 @@ public J.ForLoop visitForLoop(J.ForLoop forLoop, ExecutionContext ctx) {
             return elem;
         }
     }
-
-    ;
 }
diff --git a/src/test/java/org/openrewrite/staticanalysis/NeedBracesTest.java b/src/test/java/org/openrewrite/staticanalysis/NeedBracesTest.java
@@ -40,8 +40,8 @@
   "UnusedAssignment",
   "ConstantConditions",
   "ClassInitializerMayBeStatic",
-  "UnnecessaryReturnStatement"
-})
+  "UnnecessaryReturnStatement",
+  "DuplicateCondition"})
 class NeedBracesTest implements RewriteTest {
     @Override
     public void defaults(RecipeSpec spec) {
@@ -68,31 +68,31 @@ class Test {
                   static void addToWhile() {
                       while (true) ;
                   }
-
+              
                   static void addToWhileWithBody() {
                       while (true) return;
                   }
-
+              
                   static void addToIf(int n) {
                       if (n == 1) return;
                       // foo
                   }
-
+              
                   static void addToIfElse(int n) {
                       if (n == 1) return;
                       else return;
                   }
-
+              
                   static void addToIfElseIfElse(int n) {
                       if (n == 1) return;
                       else if (n == 2) return;
                       else return;
                   }
-
+              
                   static void addToDoWhile(Object obj) {
                       do obj.notify(); while (true);
                   }
-
+              
                   static void addToIterativeFor(Object obj) {
                       for (int i = 0; ; ) obj.notify();
                   }
@@ -104,28 +104,28 @@ static void addToWhile() {
                       while (true) {
                       }
                   }
-
+              
                   static void addToWhileWithBody() {
                       while (true) {
                           return;
                       }
                   }
-
+              
                   static void addToIf(int n) {
                       if (n == 1) {
                           return;
                       }
                       // foo
                   }
-
+              
                   static void addToIfElse(int n) {
                       if (n == 1) {
                           return;
                       } else {
                           return;
                       }
                   }
-
+              
                   static void addToIfElseIfElse(int n) {
                       if (n == 1) {
                           return;
@@ -135,13 +135,13 @@ static void addToIfElseIfElse(int n) {
                           return;
                       }
                   }
-
+              
                   static void addToDoWhile(Object obj) {
                       do {
                           obj.notify();
                       } while (true);
                   }
-
+              
                   static void addToIterativeFor(Object obj) {
                       for (int i = 0; ; ) {
                           obj.notify();
@@ -164,7 +164,7 @@ class Test {
                   static void emptyWhile() {
                       while (true) ;
                   }
-
+              
                   static void emptyForIterative() {
                       for (int i = 0; i < 10; i++) ;
                   }
@@ -185,26 +185,26 @@ class Test {
                   static void allowIf(int n) {
                       if (n == 1) return;
                   }
-
+              
                   static void allowIfElse(int n) {
                       if (n == 1) return;
                       else return;
                   }
-
+              
                   static void allowIfElseIfElse(int n) {
                       if (n == 1) return;
                       else if (n == 2) return;
                       else return;
                   }
-
+              
                   static void allowWhileWithBody() {
                       while (true) return;
                   }
-
+              
                   static void allowDoWhileWithBody(Object obj) {
                       do obj.notify(); while (true);
                   }
-
+              
                   static void allowForIterativeWithBody(Object obj) {
                       for (int i = 0; ; ) obj.notify();
                   }
@@ -225,11 +225,11 @@ class Test {
                   static void doNotAllowWhileWithEmptyBody() {
                       while (true) ;
                   }
-
+              
                   static void doNotAllowDoWhileWithEmptyBody(Object obj) {
                       do ; while (true);
                   }
-
+              
                   static void doNotAllowForIterativeWithEmptyBody(Object obj) {
                       for (int i = 0; ; ) ;
                   }
@@ -241,12 +241,12 @@ static void doNotAllowWhileWithEmptyBody() {
                       while (true) {
                       }
                   }
-
+              
                   static void doNotAllowDoWhileWithEmptyBody(Object obj) {
                       do {
                       } while (true);
                   }
-
+              
                   static void doNotAllowForIterativeWithEmptyBody(Object obj) {
                       for (int i = 0; ; ) {
                       }

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,8 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`private static class NeedBracesVisitor extends JavaIsoVisitor<ExecutionContext> {`
	`63`	`+`
	`64`	`+ @SuppressWarnings("NotNullFieldNotInitialized")`
`63`	`65`	`NeedBracesStyle needBracesStyle;`
`64`	`66`
`65`	`67`	`/**`
`@@ -92,10 +94,16 @@ private <T extends Statement> J.Block buildBlock(Statement owner, T element) {`
`92`	`94`	`}`
`93`	`95`
`94`	`96`	`@Override`
`95`		`- public J visit(@Nullable Tree tree, ExecutionContext ctx) {`
`96`		`- if (tree instanceof JavaSourceFile) {`
	`97`	`+ public @Nullable J visit(@Nullable Tree tree, ExecutionContext ctx) {`
	`98`	`+ if (tree instanceof SourceFile) {`
`97`	`99`	`SourceFile cu = (SourceFile) requireNonNull(tree);`
`98`		`- needBracesStyle = cu.getStyle(NeedBracesStyle.class) == null ? Checkstyle.needBracesStyle() : cu.getStyle(NeedBracesStyle.class);`
	`100`	`+ // Python don't need none of your curly braces`
	`101`	`+ if (cu.getSourcePath().toString().endsWith(".py")) {`
	`102`	`+ return (J) tree;`
	`103`	`+ }`
	`104`	`+ needBracesStyle = cu.getStyle(NeedBracesStyle.class) == null ?`
	`105`	`+ Checkstyle.needBracesStyle() :`
	`106`	`+ cu.getStyle(NeedBracesStyle.class, new NeedBracesStyle(false, false));`
`99`	`107`	`}`
`100`	`108`	`return super.visit(tree, ctx);`
`101`	`109`	`}`
`@@ -201,6 +209,4 @@ public J.ForLoop visitForLoop(J.ForLoop forLoop, ExecutionContext ctx) {`
`201`	`209`	`return elem;`
`202`	`210`	`}`
`203`	`211`	`}`
`204`		`-`
`205`		`- ;`
`206`	`212`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,8 @@`
`40`	`40`	`"UnusedAssignment",`
`41`	`41`	`"ConstantConditions",`
`42`	`42`	`"ClassInitializerMayBeStatic",`
`43`		`- "UnnecessaryReturnStatement"`
`44`		`-})`
	`43`	`+ "UnnecessaryReturnStatement",`
	`44`	`+ "DuplicateCondition"})`
`45`	`45`	`class NeedBracesTest implements RewriteTest {`
`46`	`46`	`@Override`
`47`	`47`	`public void defaults(RecipeSpec spec) {`
`@@ -68,31 +68,31 @@ class Test {`
`68`	`68`	`static void addToWhile() {`
`69`	`69`	`while (true) ;`
`70`	`70`	`}`
`71`		`-`
	`71`	`+`
`72`	`72`	`static void addToWhileWithBody() {`
`73`	`73`	`while (true) return;`
`74`	`74`	`}`
`75`		`-`
	`75`	`+`
`76`	`76`	`static void addToIf(int n) {`
`77`	`77`	`if (n == 1) return;`
`78`	`78`	`// foo`
`79`	`79`	`}`
`80`		`-`
	`80`	`+`
`81`	`81`	`static void addToIfElse(int n) {`
`82`	`82`	`if (n == 1) return;`
`83`	`83`	`else return;`
`84`	`84`	`}`
`85`		`-`
	`85`	`+`
`86`	`86`	`static void addToIfElseIfElse(int n) {`
`87`	`87`	`if (n == 1) return;`
`88`	`88`	`else if (n == 2) return;`
`89`	`89`	`else return;`
`90`	`90`	`}`
`91`		`-`
	`91`	`+`
`92`	`92`	`static void addToDoWhile(Object obj) {`
`93`	`93`	`do obj.notify(); while (true);`
`94`	`94`	`}`
`95`		`-`
	`95`	`+`
`96`	`96`	`static void addToIterativeFor(Object obj) {`
`97`	`97`	`for (int i = 0; ; ) obj.notify();`
`98`	`98`	`}`
`@@ -104,28 +104,28 @@ static void addToWhile() {`
`104`	`104`	`while (true) {`
`105`	`105`	`}`
`106`	`106`	`}`
`107`		`-`
	`107`	`+`
`108`	`108`	`static void addToWhileWithBody() {`
`109`	`109`	`while (true) {`
`110`	`110`	`return;`
`111`	`111`	`}`
`112`	`112`	`}`
`113`		`-`
	`113`	`+`
`114`	`114`	`static void addToIf(int n) {`
`115`	`115`	`if (n == 1) {`
`116`	`116`	`return;`
`117`	`117`	`}`
`118`	`118`	`// foo`
`119`	`119`	`}`
`120`		`-`
	`120`	`+`
`121`	`121`	`static void addToIfElse(int n) {`
`122`	`122`	`if (n == 1) {`
`123`	`123`	`return;`
`124`	`124`	`} else {`
`125`	`125`	`return;`
`126`	`126`	`}`
`127`	`127`	`}`
`128`		`-`
	`128`	`+`
`129`	`129`	`static void addToIfElseIfElse(int n) {`
`130`	`130`	`if (n == 1) {`
`131`	`131`	`return;`
`@@ -135,13 +135,13 @@ static void addToIfElseIfElse(int n) {`
`135`	`135`	`return;`
`136`	`136`	`}`
`137`	`137`	`}`
`138`		`-`
	`138`	`+`
`139`	`139`	`static void addToDoWhile(Object obj) {`
`140`	`140`	`do {`
`141`	`141`	`obj.notify();`
`142`	`142`	`} while (true);`
`143`	`143`	`}`
`144`		`-`
	`144`	`+`
`145`	`145`	`static void addToIterativeFor(Object obj) {`
`146`	`146`	`for (int i = 0; ; ) {`
`147`	`147`	`obj.notify();`
`@@ -164,7 +164,7 @@ class Test {`
`164`	`164`	`static void emptyWhile() {`
`165`	`165`	`while (true) ;`
`166`	`166`	`}`
`167`		`-`
	`167`	`+`
`168`	`168`	`static void emptyForIterative() {`
`169`	`169`	`for (int i = 0; i < 10; i++) ;`
`170`	`170`	`}`
`@@ -185,26 +185,26 @@ class Test {`
`185`	`185`	`static void allowIf(int n) {`
`186`	`186`	`if (n == 1) return;`
`187`	`187`	`}`
`188`		`-`
	`188`	`+`
`189`	`189`	`static void allowIfElse(int n) {`
`190`	`190`	`if (n == 1) return;`
`191`	`191`	`else return;`
`192`	`192`	`}`
`193`		`-`
	`193`	`+`
`194`	`194`	`static void allowIfElseIfElse(int n) {`
`195`	`195`	`if (n == 1) return;`
`196`	`196`	`else if (n == 2) return;`
`197`	`197`	`else return;`
`198`	`198`	`}`
`199`		`-`
	`199`	`+`
`200`	`200`	`static void allowWhileWithBody() {`
`201`	`201`	`while (true) return;`
`202`	`202`	`}`
`203`		`-`
	`203`	`+`
`204`	`204`	`static void allowDoWhileWithBody(Object obj) {`
`205`	`205`	`do obj.notify(); while (true);`
`206`	`206`	`}`
`207`		`-`
	`207`	`+`
`208`	`208`	`static void allowForIterativeWithBody(Object obj) {`
`209`	`209`	`for (int i = 0; ; ) obj.notify();`
`210`	`210`	`}`
`@@ -225,11 +225,11 @@ class Test {`
`225`	`225`	`static void doNotAllowWhileWithEmptyBody() {`
`226`	`226`	`while (true) ;`
`227`	`227`	`}`
`228`		`-`
	`228`	`+`
`229`	`229`	`static void doNotAllowDoWhileWithEmptyBody(Object obj) {`
`230`	`230`	`do ; while (true);`
`231`	`231`	`}`
`232`		`-`
	`232`	`+`
`233`	`233`	`static void doNotAllowForIterativeWithEmptyBody(Object obj) {`
`234`	`234`	`for (int i = 0; ; ) ;`
`235`	`235`	`}`
`@@ -241,12 +241,12 @@ static void doNotAllowWhileWithEmptyBody() {`
`241`	`241`	`while (true) {`
`242`	`242`	`}`
`243`	`243`	`}`
`244`		`-`
	`244`	`+`
`245`	`245`	`static void doNotAllowDoWhileWithEmptyBody(Object obj) {`
`246`	`246`	`do {`
`247`	`247`	`} while (true);`
`248`	`248`	`}`
`249`		`-`
	`249`	`+`
`250`	`250`	`static void doNotAllowForIterativeWithEmptyBody(Object obj) {`
`251`	`251`	`for (int i = 0; ; ) {`
`252`	`252`	`}`