SONARPY-1235 Prevent executing the same rule again in case of successful scanWithoutParsing (#1327)

Author: guillaume-dequenne

sonar-python-plugin/src/main/java/org/sonar/plugins/python/PythonScanner.java

@@ -24,8 +24,12 @@
 import java.io.File;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import javax.annotation.CheckForNull;
@@ -76,6 +80,7 @@ public class PythonScanner extends Scanner {
   private final NoSonarFilter noSonarFilter;
   private final PythonCpdAnalyzer cpdAnalyzer;
   private final PythonIndexer indexer;
+  private final Map<InputFile, Set<PythonCheck>> checksExecutedWithoutParsingByFiles = new HashMap<>();
 
   public PythonScanner(
     SensorContext context, PythonChecks checks,
@@ -120,7 +125,8 @@ protected void scanFile(InputFile inputFile) {
     }
     List<PythonSubscriptionCheck> checksBasedOnTree = new ArrayList<>();
     for (PythonCheck check : checks.all()) {
-      if (!isCheckApplicable(check, fileType)) {
+      if (!isCheckApplicable(check, fileType)
+        || checksExecutedWithoutParsingByFiles.getOrDefault(inputFile, Collections.emptySet()).contains(check)) {
         continue;
       }
       if (check instanceof PythonSubscriptionCheck) {
@@ -151,6 +157,9 @@ public boolean scanFileWithoutParsing(InputFile inputFile) {
       if (!check.scanWithoutParsing(inputFileContext)) {
         return false;
       }
+      Set<PythonCheck> executedChecks = checksExecutedWithoutParsingByFiles.getOrDefault(inputFile, new HashSet<>());
+      executedChecks.add(check);
+      checksExecutedWithoutParsingByFiles.putIfAbsent(inputFile, executedChecks);
     }
 
     return restoreAndPushMeasuresIfApplicable(inputFile);

sonar-python-plugin/src/test/java/org/sonar/plugins/python/PythonSensorTest.java

@@ -128,6 +128,7 @@ public class PythonSensorTest {
   private static final String FILE_COMPLEXITY_RULE_KEY = "FileComplexity";
   private static final String CUSTOM_REPOSITORY_KEY = "customKey";
   private static final String CUSTOM_RULE_KEY = "key";
+  private static final String RULE_CRASHING_ON_SCAN_KEY = "key2";
 
   private static final Version SONARLINT_DETECTABLE_VERSION = Version.create(6, 0);
 
@@ -141,7 +142,7 @@ public String repositoryKey() {
 
     @Override
     public List<Class> checkClasses() {
-      return Collections.singletonList(MyCustomRule.class);
+      return List.of(MyCustomRule.class, RuleCrashingOnRegularScan.class);
     }
   }};
   private static Path workDir;
@@ -177,6 +178,24 @@ public void endOfAnalysis(CacheContext cacheContext) {
     }
   }
 
+  @Rule(
+    key = RULE_CRASHING_ON_SCAN_KEY,
+    name = "rule_crashing_on_scan",
+    description = "desc",
+    tags = {"bug"})
+  public static class RuleCrashingOnRegularScan implements PythonCheck {
+
+    @Override
+    public void scanFile(PythonVisitorContext visitorContext) {
+      throw new IllegalStateException("Should not be executed!");
+    }
+
+    @Override
+    public boolean scanWithoutParsing(PythonInputFileContext inputFile) {
+      return true;
+    }
+  }
+
   private final File baseDir = new File("src/test/resources/org/sonar/plugins/python/sensor").getAbsoluteFile();
 
   private SensorContextTester context;
@@ -1058,6 +1077,50 @@ public void read_cpd_tokens_cache_disabled() {
     assertThat(tokensLines.get(0).getValue()).isEqualTo("pass");
   }
 
+  @Test
+  public void cpd_tokens_failure_does_not_execute_checks_multiple_times() throws IOException {
+    activeRules = new ActiveRulesBuilder()
+      .addRule(new NewActiveRule.Builder()
+        .setRuleKey(RuleKey.of(CUSTOM_REPOSITORY_KEY, RULE_CRASHING_ON_SCAN_KEY))
+        .build())
+      .build();
+
+    InputFile inputFile = inputFile("pass.py", Type.MAIN, InputFile.Status.SAME);
+
+    TestReadCache readCache = getValidReadCache();
+    byte[] serializedSymbolTable = toProtobufModuleDescriptor(Collections.emptySet()).toByteArray();
+    readCache.put(IMPORTS_MAP_CACHE_KEY_PREFIX + inputFile.key(), String.join(";", Collections.emptyList()).getBytes(StandardCharsets.UTF_8));
+    readCache.put(PROJECT_SYMBOL_TABLE_CACHE_KEY_PREFIX + inputFile.key(), serializedSymbolTable);
+
+    TestWriteCache writeCache = new TestWriteCache();
+    writeCache.bind(readCache);
+
+    context.setPreviousCache(readCache);
+    context.setNextCache(writeCache);
+    context.setCacheEnabled(true);
+    context.setSettings(
+      new MapSettings()
+        .setProperty("sonar.python.skipUnchanged", true)
+        .setProperty("sonar.internal.analysis.failFast", true)
+    );
+
+    sensor().execute(context);
+
+    // Verify the written CPD tokens
+    List<TokensLine> tokensLines = context.cpdTokens("moduleKey:pass.py");
+    assertThat(tokensLines)
+      .isNotNull()
+      .hasSize(1);
+
+    assertThat(tokensLines.get(0).getValue()).isEqualTo("pass");
+
+    // Verify that we carried the tokens over to the next cache
+    List<Token> expectedTokens = List.of(new TokenImpl(passToken(inputFile.uri())));
+
+    assertThat(writeCache.getData())
+      .containsEntry(Caching.CPD_TOKENS_CACHE_KEY_PREFIX + inputFile.key(), CpdSerializer.toBytes(expectedTokens));
+  }
+
   private com.sonar.sslr.api.Token passToken(URI uri) {
     return com.sonar.sslr.api.Token.builder()
       .setType(PythonKeyword.PASS)